C++类对象成员、动态对象、new、delete运算符申请动态空间（C++初学面向对象）

约定不等于承诺〃 2022-11-12 01:43 303阅读 0赞

### 文章目录 ###

*   *  一、类成员对象
     *   *   *  1、类的对象
             *  2、具体参考代码
     *  二、动态对象与new、delete
     *   *   *  1、C语言中为类的对象开辟动态空间
             *  2、C++的new开辟动态空间：类型名 \*p= new 类型名
             *  3、请自定义类的动态空间，p3是一个对象指针
             *  4、申请数组的动态空间，p4是一个数组
             *  5、C++申请动态空间完整练习代码
     *  三、动态对象（传参）

## 一、类成员对象 ##

#### 1、类的对象 ####

简单来说，类成员对象就是在类中定义其他类的实例化对象，并调用其他的成员对象的有参/无参构造函数。

例如：  
定义三个Room、Chair、Person，  
然后在Person类的定义中，  
再定义Room、Chair的实例化对象room和chair，  
定义Person对象传入3个有参构造函数需要的参数，  
并通过room、chair这两个对象对它们的成员数据进行赋值，  
同时在Person类中引用room、chair对象的数据进行输出。

#### 2、具体参考代码 ####

#include <iostream>
    #include <string.h>
    #include <stdlib.h>
    using namespace std;
    
    //定义一个房间类 
    class Room
    { 
    public:
    	string room_name;  //定义一个共有成员，字符串类型的名字
    	//定义有参构造函数
    	Room(string name)
    	{ 
    		room_name= name;
    		cout << "此为Room的构造函数" << endl;
    	} 
    	~Room()
    	{ 
    		cout << "This is Room function done..." << endl;
    	}
    };
    
    //再定义一个椅子类
    class Chair
    { 
    public:
    	string chair_name;  //定义一个共有成员，字符串类型的名字 
    	//定义有参构造函数
    	Chair(string name)
    	{ 
    		chair_name= name;
    		cout << "此为Chair的构造函数" << endl;
    	} 
    	~Chair()
    	{ 
    		cout << "This is Chair function done..." << endl;
    	}
    };
     
    //定义一个人的类 
    class Person
    { 
    public:
    	
    	//定义有参构造函数
    	
    	//不能直接这样写调用其他类对象的有参构造 
    	/*Person(string p_name, string r_name, string c_name) { //对Person的成员进行赋值 per_name= p_name; room.room_name= r_name; chair.chair_name= c_name; } */
    	
    	//必须使用初始化列表，才可以调用其他类对象的有参构造
    	Person(string p_name, string r_name, string c_name):per_name(p_name), room(r_name), chair(c_name){  
    	cout << "此为Person的构造函数" << endl;
    	}
    	
    	//定义析构函数 
    	~Person()
    	{ 
    		cout << "This is Person function done..." << endl;
    	}
    	
    	string per_name;  //定义一个共有成员，字符串类型的名字 
    	//该类的成员中包含两个其他类的对象
    	Room room;  //定义一个Room类的对象room，也就是让一个类的对象作为另一个类的成员 
    	Chair chair;  //定义一个Chair类的对象chair
    	
    	//定义Person的成员函数，输出Person的3个成员数据 
    	void show()
    	{ 
    		cout << per_name << room.room_name << chair.chair_name << endl;
    	} 
    };
     
    int main()
    { 
    	//实例化Person对象，传入三个参数
    	Person p1("Chung", "在520房间", "的椅子上。");
    	p1.show();
    	return 0;
    }

## 二、动态对象与new、delete ##

#### 1、C语言中为类的对象开辟动态空间 ####

//假如已经定义了一个Box类，则在C语言中如下开辟动态空间：
    void test01()
    { 
    	//用malloc申请一段动态内存空间 
    	Box *p= (Box*)malloc(sizeof(Box));    //空间大小为类Box的大小 
    	free(p);  //使用完了释放内存空间 
    }

#### 2、C++的new开辟动态空间：类型名 \*p= new 类型名 ####

在C++语言中申请普通类型的动态空间：类型名 \*p= new 类型名，p2是一个指针 ：

void test02()
    { 
    	//申请一段int类型的空间并赋值给p2指针，大小为sizeof(int) 
    	int *p2= new int;  
    	*p2= 99;
    	cout << "*p2= " << *p2 << endl;
    	delete p2;  //使用完了释放内存空间 
    }

#### 3、请自定义类的动态空间，p3是一个对象指针 ####

void test03()
    { 
    	//申请一段Box类型的空间并赋值给p3指针，大小为sizeof(Box) 
    	Box *p3= new Box; 
    	(*p3).a= 666;
    	cout << "p3对象中的a= " << (*p3).a << endl;
    	delete p3;  //使用完了释放内存空间 
    }

#### 4、申请数组的动态空间，p4是一个数组 ####

void test04()
    { 
    	int *p4= new int[10];  //申请一段int数组类型的空间，大小为sizeof(int[10])，实际上该指针指向的是数组元素的首地址 
    	//给数组元素赋值
    	for(int i=0; i<10; i++)
    	{ 
    		p4[i]= i+10;
    	} 
    	//输出数组元素的值 
    	for(int i=0; i<10; i++)
    	{ 
    		cout << p4[i] << " ";
    	} 
    	cout << endl;
    	//释放内存空间，不能直接delete p4; 这样只是释放了首元素的空间
    	delete []p4; 
    }

#### 5、C++申请动态空间完整练习代码 ####

#include <iostream>
    #include <string.h>
    #include <stdlib.h> //需要用到malloc 
    using namespace std;
    
    //定义一个盒子类 
    class Box
    { 
    public:
    	Box()  //定义构造函数 
    	{ 
    		cout << "Box的无参构造" << endl;
    	}
    	~Box()  //定义析构函数 
    	{ 
    		cout << "Box的析构函数" << endl;
    	}
    	int a;  //私有成员数据 
    };
    
    //在C语言中动态申请空间
    void test01()
    { 
    	//用malloc申请一段动态内存空间 
    	Box *p= (Box*)malloc(sizeof(Box));    //空间大小为类Box的大小 
    	free(p);  //使用完了释放内存空间 
    } 
    
    //在C++语言中申请普通类型的动态空间：类型名 *p= new 类型名，p2是一个指针 
    void test02()
    { 
    	//申请一段int类型的空间并赋值给p2指针，大小为sizeof(int) 
    	int *p2= new int;  
    	*p2= 99;
    	cout << "*p2= " << *p2 << endl;
    	delete p2;  //使用完了释放内存空间 
    } 
    
    //在C++语言中申请自定义类的动态空间，p3是一个对象指针 
    void test03()
    { 
    	//申请一段Box类型的空间并赋值给p3指针，大小为sizeof(Box) 
    	Box *p3= new Box; 
    	(*p3).a= 666;
    	cout << "p3对象中的a= " << (*p3).a << endl;
    	delete p3;  //使用完了释放内存空间 
    } 
    
    //在C++语言中申请数组的动态空间，p4是一个数组 
    void test04()
    { 
    	int *p4= new int[10];  //申请一段int数组类型的空间，大小为sizeof(int[10])，实际上该指针指向的是数组元素的首地址 
    	//给数组元素赋值
    	for(int i=0; i<10; i++)
    	{ 
    		p4[i]= i+10;
    	} 
    	//输出数组元素的值 
    	for(int i=0; i<10; i++)
    	{ 
    		cout << p4[i] << " ";
    	} 
    	cout << endl;
    	//释放内存空间，不能直接delete p4; 这样只是释放了首元素的空间
    	delete []p4; 
    }
    
    int main()
    { 
    	//test01();
    	//test02();
    	test03();
    	test04();
    	return 0;
    }

## 三、动态对象（传参） ##

与上文动态空间的申请同理，只是需要传入参数。  
注意：若申请的是对象数组，则不能实例化带有参数构造函数的类，只能是无参构造函数类。

#include <iostream>
    #include <string.h>
    #include <stdlib.h> //需要用到malloc 
    using namespace std;
    
    //定义一个盒子类 
    class Box
    { 
    public:
    	Box()  //定义构造函数 
    	{ 
    		cout << "Box的无参构造" << endl;
    	}
    	//使用初始化列表定义有参构造函数
    	Box(int h, int w, int len):height(h), width(w), length(len)   
    	{ 
    		cout << "Box的有参构造" << endl;
    	}
    	~Box()  //定义析构函数 
    	{ 
    		cout << "Box的析构函数" << endl;
    	}
    private:
    	int height;  //私有成员数据 
    	int width;
    	int length;
    };
    
    //定义测试函数
    void test()
    { 
    	//申请一段Box类型的动态空间并赋值给p指针，大小为sizeof(Box)
    	//并传入构造函数的参数 
    	Box *p= new Box(1, 2, 3);   
    	delete p;  //释放申请的内存空间 
    	// 
    	//申请动态空间，调用无参构造的对象数组 
    	cout << "-------------------------"  << endl; 
    	Box *p2= new Box[5];   
    	delete []p2;  //释放对象数组的内存空间 
    } 
    
    int main()
    { 
    	test();
    }

![02][]

[02]: /images/20221022/0f24de3d970b4859832e9627cf641c50.png