C++的对象特性和友元你真的了解吗

目录

对象特征构造函数和析构函数函数的分类以及调用拷贝构造函数调用时机构造函数调用规则深拷贝与浅拷贝初始化列表类对象作为类变量静态成员成员变量和成员函数分开储存this指针的用途空指针访问成员const修饰成员函数友元全局函数做友元类做友元成员函数做友元总结

对象特征

构造函数和析构函数

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

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

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

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

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

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

2.函数名称与类名相同

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

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

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

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

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

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

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

#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("pau");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();  /*cout << "p2的年龄：" << p2.age << endl;cout << "p3的年龄：" << p3.age << endl;*///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("pau");return 0;}

拷贝构造函数调用时机

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

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

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

3.以值方式返回局部对象

#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("pau");return 0;}

构造函数调用规则

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

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

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

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

构造函数调用规则如下

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

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

#include<iostream>using namespace std;//构造函数的调用规则//1.创建了一个类，c++编译器会给每个类都添加至少三个函数//默认构造  （空实现）//析构函数  （空实现）//拷贝构造  （值拷贝）//2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造//如果我们写了拷贝构造函数，编译器不再提供其他构造函数了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;};//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("pau");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("pau");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;}*///初始化列表初始化属性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("pau");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("pau");return 0;}

静态成员

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

静态成员分为：

静态成员变量

所有对象共享一份数据

在编译阶段分配内存

类内声明，类外初始化

静态成员函数

所有对象共享同一个函数

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

#include<iostream>using namespace std;//静态成员函数//所有对象共享同一个函数//静态成员函数只能访问静态成员变量class person {public://静态成员函数static void func() {m_a = 100;//静态成员函数可以访问静态成员变量//m_b = 200;//静态成员函数不可以recco访问非静态成员变量，无法区分到底是哪个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("pau");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("pau");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("pau");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("pau");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("pau");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("pau");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("pau");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("pau");return 0;}

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注www.887551.com的更多内容!