(文章目录)
1. 封装
第一点
<font color=red>1.将数据和方法放到定义一起</font>
<font color=Blue>c++类的成员函数 即方法 ,成员变量即数据</font>
#include<iostream>
using namespace std;
class stack
{
public:
void push(int x);//成员函数
private:
int b;//成员变量
};
int main()
{
return 0;
}
第二点
<font color=red>2.把想给你看到的数据给你，不想给你看封装起来</font> <font color=Blue>访问限定符： public (共有的) protected (保护) private (私有) a属于public 类中 ，属于想给你看到的数据 ，而 b属于 private 类中，属于 不想给你看到的</font>
#include<iostream>
using namespace std;
class stack
{
public:
int a;
private:
int b;
};
int main()
{
return 0;
}
2.关于c语言和c++对于struct用法
<font color=red>c语言中struct是用来定义结构体的</font>
struct listnode_C//c语言定义结构体
{
int val;
struct listnode_C* prev;
struct listnode_C* next;
};
<font color=red>c++中，兼容c的struct定义结构体的用法，但是同时struct也可以用来定义类</font>
struct listnode_CPP//C++定义类，把listnode_CPP看作类名
{
int val;
listnode_CPP* prev;
listnode_CPP* next;
listnode_CPP* createnode(int val);//定义成员函数
};
3. c++中使用class和struct定义类的区别？
<font color=red>默认访问限定符不同</font>
struct listnode_CPP//使用struct
{
int val;
listnode_CPP* prev;
listnode_CPP* next;
};
<font color=Blue>使用struct 默认访问限定符为 public </font>
class listnode_CPP//使用class
{
int val;
listnode_CPP* prev;
listnode_CPP* next;
};
<font color=Blue>使用class 默认访问限定符为private</font>
4. 类的实例化
<font color=Blue>用类类型创建对象的过程，成为类的实例化 类也可以看作是设计图，而类的实例化则使用图纸建造房子</font>
1.成员变量的声明和定义
#include<iostream>
using namespace std;
class stack
{
public:
void push(int x);//成员函数
private:
int a;//成员变量的声明
};
int mian()
{
//类的实例化,通过stack这个类 创建s1这个对象
stack s1;//相当于将成员函数定义
return 0;
}
2.成员函数的定义和声明
1.在类外面定义
#include<iostream>
using namespace std;
class stack
{
public:
void push(int x);//成员函数
void pop();
private:
int a;
};
void stack::pop()//在类外面定义
{
//...
}
int mian()
{
stack s1;
s1.pop();
return 0;
}
2. 在类里面定义
#include<iostream>
using namespace std;
class stack
{
public:
void push(int x)
{
//.....
}
void pop();//成员函数的声明
private:
int a;
};
int main()
{
stack s1;
s1.push(1);
return 0;
}
5.类的大小计算
#include<iostream>
using namespace std;
class stack
{
public:
void push(int x);
void pop();//成员函数
void destory();
int a;
private:
int b;//成员变量
};
int main()
{
stack s1;
cout << sizeof(s1) << endl;//结果为8
return 0;
}
<font color=Blue>因为成员函数有3个，成员变量有2个，故只计算了成员变量的大小 </font>
1.只计算成员变量的原因
<font color=Blue>一个类实例化N个对象，每个对象的成员变量都可以存储不同的值，但是调用的函数却是同一个，如果每个对象都放成员函数，而这些成员函数确是一样的，</font><font color=red>就会浪费空间</font>
举例
#include<iostream>
using namespace std;
class stack
{
public:
void push(int x);
void pop();//成员函数
void destory();
int a;
private:
int b;//成员变量
};
int main()
{
stack s1;
s1.a = 5;
s1.pop();
stack s2;
s2.a = 4;
s2.pop();
stack s3;
s3.a = 3;
s3.pop();
return 0;
}
<font color=Blue>通过stack这个类，实例化出s1 、s2、s3 这三个对象 s1.a=5 s2.a =4 s3.a=3</font> <font color=red>成员变量a每次被赋予都是不同的值 但每次pop这个成员函数的调用是相同的</font>
2. 如何计算一个类的实例化的对象的大小
<font color=Blue>计算成员变量之和，并且考虑内存对齐规则</font> <font color=red>没有成员变量的大小为1</font>
举例
#include<iostream>
using namespace std;
class A1//类中既有成员函数，又有成员变量
{
public:
void f1()
{
//...
}
private:
int a;
char b;
};
class A2//类中仅有成员函数
{
public:
void f2()
{
//...
}
};
class A3//类中什么也没有
{
//...
};
int main()
{
cout << sizeof(A1) << endl;//8
cout << sizeof(A2) << endl;//1
cout << sizeof(A3) << endl;//1
return 0;
}
<font color=Blue>A1 VS默认对齐数为8 a为int，字节大小为4 ， 4<8 即a的对齐数为 4 b为char,字节大小为1， 1<8 即b的对齐数为1 4为最大对齐数，整体结构需为最大对齐数的整数倍 整体结构为5 ， 5>4 , 补齐后为 8 即结果为 8</font>
为什么没有成员变量的大小为1(如A2 A3），而不是0？
<font color=Blue>开一个字节不是为了存数据，而表示对象存在</font>
#include<iostream>
using namespace std;
class A2//类中仅有成员函数
{
public:
void f2()
{
//...
}
};
int main()
{
A2 a;
A2 aa;
A2 aaa;
return 0;
}
<font color=Blue>当使用A2类实例化多个对象时，若类的大小为0，没有空间存在，则 &a,&aa,&aaa，就会报错，故选取一个字节是为了表示数据存在</font>
6. this指针
1. 隐藏的this指针
#include<iostream>
using namespace std;
class date
{
public:
void init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
date d;
d.init(2022, 12, 11);
d.print();
return 0;//2022-12-11
}
<font color=Blue>明明print中没有参数的存在，为何可以出现结果？</font>
<font color=Blue>通过隐含的this指针，找到类中的私有 _year _month _day(在类中私有可以直接调用) 从而求出结果</font>
<font color=red>同样的init成员函数也包含隐藏的this指针</font>
2. 特性
#include<iostream>
using namespace std;
class A
{
public:
void printA()
{
cout << _a << endl;
}
void show()
{
cout << "show()" << endl;
}
private:
int _a;
};
int main()
{
A* p = NULL;
p->printA();//崩溃
p->show();//正常运行
return 0;
}
<font color=Blue>因为printA和show函数都在公共代码段中，所以p->printA()和p->show()不会去p所指向的对象中寻找，这里不会崩溃</font>
<font color=red>p为NULL，this指针作为p的形参，所以this==NULL，NULL->a程序就会崩溃</font>
<font color=red>虽然this==NULL，但是输出并没有用到this指针，没有访问NULL </font>