C++笔记4.28

知识点1 new delete

使用new给基本类型申请空间

1. int main()  
2. {  
3.     int *p = NULL;  
4.     p = new int;  
5.     *p = 100;  
6.     cout << "*p = " << *p << endl;  
7.     delete p;  
8. }  

使用new申请基本类型数组空间

1. int main()  
2. {  
3.     int *arr = NULL;  
4.     arr = new int [5];//申请空间的时候没有初始化内容，值随机  
5.     int i = 0;  
6.     for (i=0;i<5;i++)  
7.     {  
8.         cout << arr[i];  
9.     }  
10.     delete [] arr;  
11.     return 0;  
12. }  

注意

new 没有加[ ] delete释放的时候就不加

new 加了[ ] delete的释放的时候就要加，不然默认只释放了数组中第一个元素

new delete给对象申请空间

new delete 给对象申请空间，申请成功后会自动调用构造函数，delete释放空间时自动调用析构函数

1. class Data  
2. {  
3. private:  
4.     int num;//成员数据占一个类的空间大小，4B  
5. public:  
6.     //成员函数不占据空间大小  
7.     Data(){}  
8.     Data (int a):num(a)  
9.     {  
10.         cout << "构造函数" << endl;  
11.     }  
12.     void setNum(int data)  
13.     {  
14.         num = data;  
15.     }  
16.   
17.     int getNum(void)  
18.     {  
19.         return num;  
20.     }  
21.     ~Data()  
22.     {  
23.         cout << "析构函数" << endl;  
24.     }  
25. };  
26.   
27. int main()  
28. {  
29.     //申请成功后自动调用Data的构造函数  
30.     Data *d = new Data(10);  
31.     //对于指针用-> 对于普通对象用.  
32.     cout << d ->getNum() << endl;  
33.     delete d;  
34. }  

知识点2 对象数组

对象数组的本质是数组，只不过数组的每个元素是类的对象

定义对象数组的时候系统会自动给数组中的每个元素调用构造函数（默认无参构造）

初始化的元素将调用有参构造，后面没有初始化的元素默认调用无参构造

尽量不要使用delete释放void

释放void*时编译器发现指向类型为void，无法从void中寻找相应的析构函数

malloc、free和new、delete不可以混搭使用（malloc是new里面的一部分函数）

知识点3 静态成员 static修饰的成员

成员分为成员变量和成员函数

使用static修饰成员变量和成员函数

被static声明的静态的成员，不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有的类的对象共享。因此，静态成员属于类而不属于对象。

1、static修饰成员变量

静态变量在编译阶段就被分配空间，对象还没有被创建时就已经分配好了空间。

因此，静态成员必须在类中声明，类外定义。

静态数据成员不属于某一个具体的对象，所以在为对象分配空间的时候不包含静态成员所占用的空间。

1. class Data  
2. {  
3. public:  
4.     int num;//普通成员变量  
5.     static int data;//静态成员变量（在内部声明）  
6. };  
7. //定义时候不用加static  
8. int Data::data = 100;  
9.   
10. int main()  
11. {  
12.     //data是静态成员变量，属于类，可以直接通过类名称::直接访问  
13.     cout << Data::data << endl;//输出100  
14.     Data::data = 200;//重新赋值  
15.     cout << Data::data << endl;//输出200  
16.   
17.     //data静态变量是所有对象共享的，可以通过对象名访问  
18.     Data ob1;  
19.     ob1.data = 300;  
20.     cout << Data::data << endl;//输出300  
21.   
22.     Data ob2;  
23.     cout << ob2.data << endl;//输出300  
24.     //普通成员变量只属于对象的，只能通过对象名访问  
25.     ob1.num = 100;  
26.     cout << "ob2.num=" << ob2.num << endl;//输出随机值  
27.     return 0;  
28. }  

2、static修饰静态函数

静态的成员变量在创建对象之前就已经存在，如果没有实例化对象，也没有静态函数，就不能够直接使用静态成员变量。

为了解决这个问题，需要使用静态成员函数！