首页 > 编程语言 >C++学习（三）

C++学习（三）

时间：2023-06-15 18:56:52浏览次数：49  
标签：const Point int age C++ Pig 学习 void

static 静态修饰的变量，必须先声明，再实现，例如 

 1 class  Person{
 2     public:
 3        startic  int age;
 4         startic initAge(){
 5             //运行异常
 6              age = 10 ;                 
 7         }
 8 }
 9 
10 
11 正确写法
12 class  Person{
13     public:
14        startic  int age;
15         startic initAge(){                          
16         }
17         void setage(){
18             age = 30;        
19         }
20 }
21 
22 int Person::age = 10;
23 void  main(){
24     Person p;
25     p.setage();
26     Person::age =32;
27     Person::initAge();
28 }
this 为什么会有this? 当通过p.setage();和getage();时， 在代码区域会保存多份代码副本， this指针指向相对应的代码区域     
 1 class Person{
 2     public:
 3         char * name;
 4         int age;
 5         int age = NULL;//C++中，int默认值是系统默认值 -64664，NULL就表示0；或者直接写0也可以。
 6         //默认持有隐式的this(Person * const this)
 7         //指针常量:只允许更改this指针地址的值，而不能更改指针地址。
 8      void change(){
 9             //此行代码运行报错，指针常量不可改地址。而常量指针(const int*)只可以改指针，不能改值
10             //this = 0x2343;
11             this->age = 88;
12      }
13 }
14 
15 
16 class Person{
17     public:
18         char * name;
19         int age;
20         int age = NULL;//C++中，int默认值是系统默认值 -64664，NULL就表示0；或者直接写0也可以。
21         //默认持有隐式的this( const Person * const this),常量指针常量，只读，不能修改地址且不能修改地址对应的值
22      void change2() const{
23             //下边2行代码都不能运行
24             this = 0x2343;
25             this->age = 88;
26      }
27 }

 

友元函数和友元类 友元函数： 
 1 #include <iostream>
 2 #include "string.h"
 3 using namespace std;
 4 
 5 class Student {
 6     private:
 7     int age ;
 8     
 9     public:
10     Student(int age){
11     this->age = age;
12     }
13     int getAge(){
14     return this->age;
15     }
16     //定义友元函数，可以访问所有私有成员
17     friend void updateAge(Student* stu,int age);
18 };
19 
20 void updateAge(Student* stu,int age){
21     cout << "原始数据： "<<stu->getAge() << endl;
22     //如果不设置友元函数则不能修改私有的age
23     stu->age = age;
24 }
25     
26 int main(){
27     Student s = Student(20) ;
28     updateAge(&s,88);
29     cout << "更改后数据："<<s.getAge() << endl;
30     getchar();
31     return 0;
32 }
33 //log:
34 原始数据： 20
35 更改后数据：88

 

友元类： 
 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Pig{
 5     private:
 6         int age;
 7         char* name;
 8         //友元类
 9         friend class PigImpl;
10     
11 };
12 
13 class PigImpl{
14     public:
15       Pig pig;
16       
17     void changeAge(int age){
18         pig.age = age;    
19     }        
20     int getAge(){
21         return pig.age;
22     }
23 };
24 
25 int main(){
26     PigImpl mPigImpl;
27     mPigImpl.changeAge(100);
28     cout << mPigImpl.getAge() <<endl;
29     return 0;
30 }

 

总结：静态函数、友元函数、构造函数、拷贝构造函数、析构函数的区别 Pig.h文件 
 1 #ifndef PIG_H
 2 #define PIG_H
 3 #include <iostream>
 4 using namespace std;
 5 
 6 
 7 class Pig {
 8 private:
 9     int age
10     char *name;
11 public:
12     static int age;
13 
14     Pig();
15 
16     Pig(char *);
17     //普通函数
18     Pig(char *, int);
19     //析构函数
20     ~Pig();
21     //拷贝构造函数
22     Pig(const Pig &pig);
23 
24     //普通函数
25     int getAge();
26 
27     char *getName();
28 
29     void setAge(int);
30 
31     void setName(char *);
32 
33     //静态函数的生命
34     static void changeTag(int age);
35 
36     //友元函数
37     friend void changeAge(Pig* pig,int age);
38     //常量指针常量
39     void showInfo() const;
40 };
41 
42 #endif
Pig.cpp文件 
 1 #include "Pig.h"
 2 
 3 /**此类是对 Pig.h声明函数的实现类*/
 4 Pig::Pig() {
 5 
 6 }
 7 
 8 Pig::Pig(char *name) {
 9 
10 }
11 
12 Pig::Pig(char *name, int age) {
13 
14 }
15 
16 Pig::~Pig() {}
17 
18 Pig::Pig(const Pig &pig) {}
19 
20 //静态属性实现，不需要写static关键字
21 int Pig::id = 188;
22 
23 //静态函数不需要写static关键字
24 void changeTag(int age){
25 
26 }
27 
28 //友元函数的实现不需要写 friend关键字，也不需要写  XXX::
29 changeAge(Pig* pig,int age){
30 
31 }
32 
33 Pig::showInfo() const {
34 
35 }
运算符重载 类外的运算符重载 
 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Point{
 5     private:
 6         int x;
 7         int y;
 8     
 9      public:
10         Point(int x, int y):x(x),y(y){}
11     
12         int getX(){
13         return this->x;
14         }
15         int getY(){
16         return this->y;
17         }
18 
19     };
20 
21 // 对象1 + 对象2。在C++、KT里是不被允许的，可以自定义重写运算符。
22 //此为类外重写，一般都是放置类内
23 Point operator + (Point p1,Point p2){
24     int x = p1.getX()+p2.getX();
25     int y = p1.getY()+p2.getY();
26     Point p(x,y);
27     return p;
28 }
29 
30 int main(){
31     Point p1(100,200);
32     Point p2(200,300);
33     Point p = p1 + p2;
34     cout << p.getX()<<"  ,  "<<p.getY() <<endl;
35     return 0;
36 }
37 //log: 300,500

 

类内的运算符重载   
 1 #include <iostream>
 2 using namespace std;
 3 
 4 class Point{
 5 private:
 6     int x;
 7     int y;
 8     
 9 public:
10     Point(int x, int y):x(x),y(y){}
11     int getX(){
12         return this->x;
13     }
14     int getY(){
15         return this->y;
16     }
17     //不需要传入两个参数，本身自己持有this，this指针指向自己的地址
18     /**
19     *const 不可变
20     * & 提高性能，如果没有 该引用的话会生成一个副本
21     * & 只是引用，给这块内存重新取别名，内存地址是一样的
22     */
23     
24     Point operator + (const Point &p2){
25         int x = this->x + p2.x;
26         int y = this->y + p2.y;
27         Point p(x,y);
28         return p;
29     }
30     //运算符重载
31     void operator ++(){
32         this->x = x+1;
33         this->y = y+1;
34      }
35     void operator ++(int){
36         this->x = x+1;
37         this->y = y+1;
38     }
39 };
40 
41 
42 int main(){
43     Point p1(100,200);
44     Point p2(200,300);
45     Point p = p1 + p2;
46     p++;
47     ++p;
48     cout << p.getX()<<"  ,  "<<p.getY() <<endl;
49     return 0;
50 }
51 //log: 302,502

 

 

 

 

标签：const,Point,int,age,C++,Pig,学习,void
From： https://www.cnblogs.com/wangybs/p/17483805.html

相关文章

  • C++学习（四）
    对象继承1#include<iostream>2usingnamespacestd;34classPerson{5public:6intage;7char*name;8Person(char*name,intage){}9};10//类默认是私有的11//public：公开继承,不加public会导致main()函数中student.age无法引用......
  • 学习Spring必学的Java基础知识----反射
    引述要学习Spring框架的技术内幕，必须事先掌握一些基本的Java知识，正所谓“登高必自卑，涉远必自迩”。以下几项Java知识和Spring框架息息相关，不可不学（我将通过一个系列分别介绍这些Java基础知识，希望对大家有所帮助。）：[1]Java反射知识-->SpringIoC[2]属性编辑器，即PropertyEditor......
  • Kong入门学习实践(4)负载均衡与正则路由
    最近在学习Kong网关，因此根据老习惯，我会将我的学习过程记录下来，一来体系化整理，二来作为笔记供将来翻看。由于我司会直接使用Kong企业版，学习过程中我会使用Kong开源版。本篇，我们学习快速配置一个最常见的基本功能：负载均衡与正则路由。关于负载均衡所谓负载均衡，就是通过负载均衡算......
  • Hibernate学习笔记
    大小写不敏感持久化类一般被定义为JavaBean，这是推荐的设计，但是并不是必须的。Hibernate也可以直接访问这些field。所有的持久化类（persistentclasses）都要求有无参的构造器，因为Hibernate必须使用Java反射机制来为你创建对象。映射文件一个映射文件看起来像这样<hibernate-mapping>......
  • python篇-工业相机学习
    1，抠出屏的图importcv2fromPILimportImagedefgetCoordinate(img):rectangle=[]gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)#灰度图ret,binary=cv2.threshold(gray,0,255,cv2.THRESH_BINARY|cv2.THRESH_OTSU)#二值化element3=......
  • vue学习记录 4
    本地服务器配置apache安装学习参考网址：（官网下载apache包的时候可能会疯狂断开链接）教程里没说，但是要管理员身份操作cmd。https://blog.csdn.net/qqhruchen/article/details/127457889?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefaul......
  • 「学习笔记」三角函数
    有关三角函数的公式、转化、证明等等\[\sin^2\alpha+\cos^2\alpha=1\\\dfrac{\sin\alpha}{\cos\alpha}=\tan\alpha\\(\sin\alpha\pm\cos\alpha)^2=1\pm2\sin\alpha\cos\alpha\\\sin\alpha=\cos\alpha\tan\alpha\\\sin......
  • redis学习八：数据类型命令及落地运用 （Zset）
    有序，附带分数，适用于排行榜1.zaddkeyscore1v1score2v2新增键值对；zrangezsetstartend查看对应范围值zrangekeystartendwithscores带着分数查看；zrevrangekey倒序查看，用法和zrange类似； 2.zrangebyscorekeyminmax取分数范围内的value；也可以在前面加上(是不......
  • Kafka入门学习
    kafka概述Kafka是一个分布式流媒体平台,类似于消息队列或企业消息传递系统。kafka官网：http://kafka.apache.org/名词解释producer：发布消息的对象称之为主题生产者（Kafkatopicproducer）topic：Kafka将消息分门别类，每一类的消息称之为一个主题（Topic）consumer：订阅消息并处理发布......
  • 碎片化学习前端之JavaScript（JS 压缩图片）
    前言图片压缩是前端开发中常见的需求，目前前端主流的解决方案有：Canvas手动实现压缩以及第三方库压缩两种方案。Canvas手动实现压缩Canvas实现压缩主要原理是：将图片绘制到canvas上，然后通过调整canvas的宽高来实现压缩。functioncompressImage(file,maxWidth,maxHeight......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99