C++的对象特性和友元是什么

这篇文章主要介绍了c++的对象特性和友元是什么的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇C++的对象特性和友元是什么文章都会有所收获，下面我们一起来看看吧。

对象特征

构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

一个对象或者变量没有初始状态，对其使用后果也是未知

同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题 

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用

• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名（）{}

构造函数，没有返回值也不写void

函数名称与类名相同

构造函数可以有参数，因此可以发生重载

程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次 

析构函数语法：~类名（）{}

析构函数，没有返回值也不写void

函数名称与类名相同，在名称前加上符号~

析构函数不可以有参数，因此不可以发生重载

程序在调用对象前会自动调用析构，无须手动调用，而且只会调用一次 

#include<iOStream>using namespace std;//对象的初始化和清理//1.构造函数  实现初始化的操作class Person {public://1构造函数//没有返回值  不用写void//函数名 与类名相同//构造函数可以有参数，可以发生重载//创建对象时，构造函数会自动调用，而且只调用一次Person() {cout<< "Person构造函数的调用" << endl;}//2.析构函数  实现清理的操作//没有返回值 不写void //函数名和类名相同 在名称前加一个~//析构函数不可以有参数，不可以发生重载//对象在销毁前 会自动调用析构函数 而且只会调用一次~Person() {cout << "Person析构函数的调用" << endl;}};//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构void test01() {Person p;//在栈上的数据，test01执行完毕后，释放这个对象} int main() {test01();system("pause");return 0;}

函数的分类以及调用

构造函数的分类以及调用

两种分类方式：

• 按参数分为：有参构造和无参构造

• 按类型分：普通构造和拷贝构造

三种调用方式：

• 括号法

• 显示法

• 隐式转换法

#include<iostream>using namespace std;//构造函数的分类及调用//分类//按照参数分类  无参构造（默认构造）和有参构造//按照类型分类  普通构造 拷贝构造class Person {public://构造函数Person() { cout << "Person的无参构造函数调用" << endl;}Person(int a) {age = a;cout << "Person的有参构造函数调用" << endl;}//拷贝构造函数Person(const Person &p) {//将传入的人身上的所有属性，拷贝到“我”身上age = p.age;cout << "Person的拷贝构造函数调用" << endl;}~Person() {cout << "Person的析构函数调用" << endl;}int age;};//调用void test01() {//1.括号法//Person p1;//默认函数调用//Person p2(10);//有参构造函数//Person p3(p2);//拷贝构造函数//注意事项//调用默认构造函数的时候，不要加()//因为下面这行代码,编译器会认为是一个函数的声明，不会认为在创建对象//Person p1();  //2.显示法//Person p1;//Person p2 = Person(10);//有参构造//Person p3 = Person(p3);//拷贝构造//Person(10);//匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象//// 注意事项2// 不要利用拷贝构造函数，初始化匿名对象  编译器会认为Person(p3) === Person p3;对象声明//Person(p3); //3.隐式转换法Person p4 = 10;//相当于 写了 Person p4 = Person(10); 有参构造Person p5 = p4;//拷贝构造}int main() {test01();system("pause");return 0;}

拷贝构造函数调用时机

拷贝构造函数调用时机通常有三种情况

使用一个已经创建完毕的对象来初始化一个新对象

值传递的方式给函数参数传值

以值方式返回局部对象

#include<iostream>using namespace std;//拷贝构造函数的调用时机//1.使用一个已经创建完毕的对象来初始化一个新对象//2.值传递的方式给函数参数传值//3.值方式返回局部对象class Person {public:Person() {cout << "Person的默认构造函数调用" << endl;}Person(int age) {cout << "Person的有参构造函数调用" << endl;m_Age = age;}Person(const Person &p) {cout << "Person的拷贝构造函数调用" << endl;m_Age = p.m_Age;}~Person() { cout << "Person析构函数调用" << endl;}int m_Age;};//拷贝构造函数的调用时机//1.使用一个已经创建完毕的对象来初始化一个新对象void test01() {Person p1(20);Person p2(p1);cout << "p2的年龄为：" << p2.m_Age << endl;}//2.值传递的方式给函数参数传值void doWork(Person p) {  } void test02() {Person p;doWork(p);} //3.值方式返回局部对象Person doWork2() {Person p1;return p1;}void test03() {Person p = doWork2();}int main() {//test01();//test02();test03();system("pause");return 0;}

 构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

默认构造函数（无参，函数体为空）

默认析构函数（无参，函数体为空）

默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造

如果用户定义拷贝构造函数，c++不再提供其他构造函数 

#include<iostream>using namespace std;//构造函数的调用规则//1.创建了一个类，c++编译器会给每个类都添加至少三个函数//默认构造  （空实现）//析构函数  （空实现）//拷贝构造  （值拷贝）//2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造//如果我们写了拷贝构造函数，编译器不再提供其他构造函数了class Person {public:Person(const Person& p) {cout << "Person的拷贝构造函数调用" << endl;m_Age = p.m_Age;} ~Person() {cout << "Person的析构函数调用" << endl;}int m_Age;};//void test01() {//Person p;//p.m_Age = 18;//Person p2(p);//cout << "p2的年龄为：" << p2.m_Age << endl;//}void test02() {Person p(28);Person p2(p);cout << "p2的年龄为：" << p2.m_Age << endl;}int main() {//test01();test02();system("pause");return 0;}

深拷贝与浅拷贝

• 浅拷贝：简单的赋值拷贝操作

• 深拷贝：在堆区重新申请空间，进行拷贝操作

#include<iostream>using namespace std;//深拷贝与浅拷贝class Person {public:Person() {cout << "Person的默认构造函数调用" << endl;}Person(int age,int height) {m_Age = age;m_Height = new int(height);cout << "Person的有参构造函数调用" << endl;}Person(const Person &p) {cout << "Person 拷贝构造函数的调用" << endl;m_Age = p.m_Age;//m_Height = p.m_Height; 编译器默认实现就是这行代码//深拷贝操作//如果不利于深拷贝在堆区创建内存，会导致浅拷贝带来的重复释放堆区问题m_Height = new int(*p.m_Height);}~Person() {//析构堆区，将堆区开辟数据做释放操作if (m_Height != NULL) {delete m_Height;m_Height = NULL;//浅拷贝带来的问题就是堆区的问题重复释放//浅拷贝的问题 要利用深拷贝进行解决}cout << "Person的析构函数调用" << endl;}int m_Age;//年龄int* m_Height;//身高};void test01() {Person p1(18,160);cout << "p1的年龄为：" << p1.m_Age <<"身高为："<<*p1.m_Height << endl;Person p2(p1);cout << "p2的年龄为：" << p2.m_Age <<"身高为："<<*p2.m_Height << endl;}int main() {test01();system("pause");return 0;}

如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题 

初始化列表

作用：c++提供了初始化列表语法，用来初始化属性

语法：构造函数（）：属性1（值1），属性2（值2）...{}

#include<iostream>using namespace std;//初始化列表class Person {public://传统初始化操作//初始化列表初始化属性Person(int a,int b,int c) :m_A(a), m_B(b), m_C(c) { }int m_A;int m_B;int m_C;};void test01() {//Person p(10, 20, 30);Person p(30,20,10);cout << "m_A = " << p.m_A << endl;cout << "m_B = " << p.m_B << endl;cout << "m_C = " << p.m_C << endl;  }int main() {test01();system("pause");return 0;}

类对象作为类变量

c++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

例如：

class A{}

class B

{

         A a;

}

B类中有对象A作为成员去，A为对象成员

#include<iostream>using namespace std;//类对象作为类成员//手机类class Phone {public:Phone(string pName) {cout << "Phone的构造函数调用" << endl;m_PName = pName;}~Phone() {cout << "Phone的析构函数调用" << endl;}//手机品牌名称string m_PName; };//人类class Person {public://Phone m_Phone = pName  隐式转换法Person(string name, string pName):m_Name(name),m_Phone(pName){cout << "Person的构造函数调用" << endl;}~Person() {cout << "Person的析构函数调用" << endl;}//姓名string m_Name;//手机Phone m_Phone;};//当其他类对象作为本类成员，构造时先构造类对象，再构造自身，析构的顺序与构造相反void test01() {Person p("张三","苹果");cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl; }int main() {test01();system("pause");return 0;}

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

静态成员变量

所有对象共享一份数据

在编译阶段分配内存

类内声明，类外初始化

静态成员函数

所有对象共享同一个函数

静态成员函数只能访问静态成员变量 

#include<iostream>using namespace std;//静态成员函数//所有对象共享同一个函数//静态成员函数只能访问静态成员变量class Person {public://静态成员函数static void func() {m_A = 100;//静态成员函数可以访问静态成员变量//m_B = 200;//静态成员函数不可以访问非静态成员变量，无法区分到底是哪个m_Bcout << "static void func的调用" << endl;}static int m_A;//静态成员变量int m_B;//非静态成员变量//静态成员函数也是有访问权限的private:static void func2() {cout << "static void func2的调用" << endl;}};int Person::m_A = 0;//有两种访问方式void test01() {//1.通过对象进行访问Person p;p.func();//2.通过类名访问Person::func();//Person::func2();类外访问不到私有的静态成员函数}int main() {test01();system("pause");return 0;}

成员变量和成员函数分开储存

在c++中，类的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

#include<iostream>using namespace std;//成员变量和成员函数是分开存储的class Person {int m_A;//非静态成员变量  属于类的对象上的static int m_B;//静态成员变量  不属于类的对象上void func() {}//非静态成员函数  不属于类的对象上static void func2() {}//静态成员函数  不属于类的对象上};int Person::m_B = 0;void test01() {Person p;//空对象占用的内存空间为：1//c++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置//每个空对象也应该有一个独一无二的内存地址cout << "size of p = "<<sizeof(p) << endl;}void test02() {Person p;cout << "size of p = " << sizeof(p) << endl;}int main() {//test01();test02();system("pause");return 0;}

this指针的用途

• this指针指向被调用的成员函数所属的对象

• this指针是隐含每一个非静态成员函数内的一种指针

• this指针不需要定义，直接使用即可

this指针的用途：

当形参和成员变量同名时，可用this指针来区分

在类的非静态成员函数中返回对象本身，可使用return * this返回 

#include<iostream>using namespace std;class Person {public:Person(int age) {//this指针指向被调用的成员函数所属的对象this->age = age;}int age;Person PersonAddAge(Person &p) {this->age += p.age;//this指向p2的指针，而*this指向的就是p2这个对象本体return *this;}}; //1.解决名称冲突void test01() {Person p1(18);cout << "p1的年龄为：" << p1.age << endl;}//2.返回对象本身用*thisvoid test02() {Person p1(10);Person p2(10);//链式编程思想p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);cout << "p2的年龄为：" << p2.age << endl;} int main() {//test01();test02();system("pause");return 0;}

空指针访问成员

c++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

#include<iostream>using namespace std;//空指针调用成员函数class Person {public: void showClassName() {cout << "this is Person class" << endl;}void showPersonAge() {//报错原因是因为传入的指针是为NULLif (this == NULL){return;}cout << "age = " <<this-> m_Age << endl;}int m_Age;};void test01() {Person* p = NULL;//p->showClassName();p->showPersonAge();}int main() {test01(); system("pause");return 0;}

const修饰成员函数

常函数

成员函数后加const后我们称这个函数为常函数

函数内不可以修改成员属性

成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

声明对象前加const称该对象为常对象

常对象只能调用常函数 

#include<iostream>using namespace std;//空指针调用成员函数class Person {public: void showClassName() {cout << "this is Person class" << endl;}void showPersonAge() {//报错原因是因为传入的指针是为NULLif (this == NULL){return;}cout << "age = " <<this-> m_Age << endl;}int m_Age;};void test01() {Person* p = NULL;//p->showClassName();p->showPersonAge();}int main() {test01(); system("pause");return 0;}

友元

友元的目的就是让一个函数或者类访问另一个类中私有成员 

友元关键字为friend  

友元的三种实现：

• 全局函数做友元

• 类做友元

• 成员函数做友元

全局函数做友元

#include<iostream>using namespace std;#include<string>//建筑物类class Building {//GoodGay全局函数是Building好朋友，可以访问Building中私有成员friend void goodGay(Building* building);public:Building() {m_SittingRoom = "客厅";m_BedRoom = "卧室";}public:string m_SittingRoom;//客厅private:string m_BedRoom;//卧室};//全局函数void goodGay(Building *building) {cout << "好基友全局函数 正在访问：" << building->m_SittingRoom << endl;cout << "好基友全局函数 正在访问："<<building->m_BedRoom << endl;}void test01() {Building building;goodGay(&building);}int main() {test01();system("pause");return 0;}

类做友元

#include<iostream>using namespace std;#include<string>//类做友元class Building;class GoodGay {public:GoodGay();void visit();//参观函数 访问Building中的属性Building* building;};class Building {//GoodGay类是本来的好朋友，可以访问本类中私有成员friend class GoodGay;public:Building();public:string m_SittiingRoom;//客厅private:string m_BedRoom;//卧室};//类外写成员函数Building::Building() {m_SittiingRoom = "客厅";m_BedRoom = "卧室";}GoodGay::GoodGay() {//创建建筑物对象building = new Building;}void GoodGay::visit() {cout << "好基友类正在访问："<<building->m_SittiingRoom << endl;cout << "好基友类正在访问：" << building->m_BedRoom << endl;}void test01() {GoodGay gg;gg.visit();}int main() {test01();system("pause");return 0;}

成员函数做友元

#include<iostream>using namespace std;#include<string>class Building;class GoodGay {public:GoodGay();void visit();//让visit函数可以访问Building中的私有成员void visit2();//让visit函数不可以访问Building中的私有成员Building* building;};class Building {//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友，可以访问私有成员friend void GoodGay:: visit();public:Building();public:string m_SittingRoom;//客厅private:string m_BedRoom;//卧室 };//类外实现成员函数Building::Building() {m_SittingRoom = "客厅";m_BedRoom = "卧室";}GoodGay::GoodGay() {building = new Building;}void GoodGay::visit() {cout << "visit函数正在访问"<<building->m_SittingRoom << endl;cout << "visit函数正在访问" << building->m_BedRoom << endl;}void GoodGay::visit2() {cout << "visit2函数正在访问" << building->m_SittingRoom << endl;//cout << "visit2函数正在访问" << building->m_BedRoom << endl;}void test01() {GoodGay gg;gg.visit();gg.visit2();}int main() {test01(); system("pause");return 0;}

关于“C++的对象特性和友元是什么”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“C++的对象特性和友元是什么”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注编程网其他教程频道。