北京建设电工证查询网站,wix怎么做网页,自己做网站打不开是怎么回事,seo在线短视频发布页运营#x1f3d6;️作者#xff1a;malloc不出对象 ⛺专栏#xff1a;C的学习之路 #x1f466;个人简介#xff1a;一名双非本科院校大二在读的科班编程菜鸟#xff0c;努力编程只为赶上各位大佬的步伐#x1f648;#x1f648; 目录前言一、再谈构造函数1.1 构造函数体赋… ️作者malloc不出对象 ⛺专栏C的学习之路 个人简介一名双非本科院校大二在读的科班编程菜鸟努力编程只为赶上各位大佬的步伐 目录前言一、再谈构造函数1.1 构造函数体赋值1.2 初始化列表二、explict关键字三、static成员3.1 特性四、匿名对象4.1 匿名对象的生命周期五、内部类六、拷贝对象时编译器做的一些优化处理七、再次理解类和对象前言
本篇文章是对类和对象剩余知识点的补充很多细节方面的东西我们需要把握住大家一定要跟着我的步伐一步步来
一、再谈构造函数
1.1 构造函数体赋值
在创建对象时编译器通过调用构造函数给对象中各个成员变量一个合适的初始值。
class Date
{
public:Date(int year, int month, int day){_year year;_month month;_day day;}
private:int _year;int _month;int _day;
};虽然上述构造函数调用之后对象中已经有了一个初始值但是不能将其称为对对象中成员变量的初始化构造函数体中的语句只能将其称为赋初值而不能称作初始化。因为初始化只能初始化一次而构造函数体内可以多次赋值。
1.2 初始化列表 初始化列表以一个冒号开始接着是一个以逗号分隔的数据成员列表每个成员变量后面跟一个放在括号中的初始值或表达式。注该成员变量可以是成员变量、成员类对象… 下面我们来看看初始化列表的使用形式
#include iostream
using namespace std;class A
{
public:A(): _a1(10), _a2(20){cout _a1 _a2 endl;}private:int _a1 1;int _a2 2;
};int main()
{A aa;return 0;
}我们来看看结果 从上述的结果我们可以发现在初始化列表中显式定义的成员变量会优先使用如果初始化列表未显式定义的成员变量会使用缺省值如果没有给缺省值的话就是随机值因为构造函数对内置类型不做处理。
注每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
下面我们接着来看看初始化列表与函数体的使用
#include iostream
#include stdlib.h
using namespace std;class A
{
public:A(): _a1(10), _a2(20), _a((int*)malloc(100)){_a1;_a2 10;_aa (int*)malloc(20);}
private:int _a1 1;int _a2 2;int* _a;int* _aa;
};int main()
{A aa;return 0;
}在初始化列表中我们先做成员变量的初始化然后在函数体中做成员变量的赋值等各项操作。当然了初始化列表并不是所有事情都能做所以我们可以在构造函数体内做。 Q看完上述初始化列表的使用那么初始化列表到底是在干什么 简单来说 初始化列表就是为每个成员变量定义!!! 那么为什么我们需要设计出初始化列表为每个成员变量定义呢我们在构造函数中也能对成员变量进行赋值操作啊
下面我们来看一个例子
#include iostream
using namespace std;class A
{
public:A(){_a1 10;_a2 20;_x 30;cout _a1 _a2 _x endl;}public:int _a1;int _a2;const int _x;
};int main()
{A aa; return 0;
}我们来看看结果 从上图我们发现对于const修饰的成员变量在程序中是编译不通过的我们来联系一下const的特性const修饰变量是不是一定要进行初始化那么在上述程序中我们没有对_x进行初始化操作并且在构造函数中_x 30也并不是初始化操作而是赋值操作对于const修饰的变量来说它是只读的所以_x 30显然也是不满足要求的那么我们该如何解决
我们想到使用缺省值对const修饰的_x进行声明我们未显式初始化时使用的就是缺省值这种方式是可行的但这个特性是在C11提出来为了解决默认构造函数不对内置类型做处理的在C11之前是如何解决的呢
出于像const修饰成员变量这样必须在定义的位置进行初始化等问题所以C之父设计出了初始化列表给每个成员变量进行定义 Q什么样的场景一定需要显式的将成员变量定义在初始化列表中呢 1、引用成员变量 2、const成员变量 3、自定义类型成员(且该类没有默认构造函数时) 引用成员变量
class A
{
public:A():_a1(1){_a1;}
private:int _a1;int _a2 10;int _a3;
};int main()
{A aa;return 0;
}我们必须要对成员变量_a3进行初始化引用 _a1的别名为_a3所以_a1发生什么变化_a3也随着会变化。 自定义类型成员找不到默认构造函数
class B
{
public:B(int b){cout B() endl;}
private:int _b;
};class A
{
public:A(): _a2(1), _ref(_a1), _x(1){_a1;_a2--;}private:int _a1 1;int _a2 2;const int _x;int _ref;B _bb;
};int main()
{A a;return 0;
}对于_bb自定义类型成员来说编译器会对它进行处理自动去调用它的默认构造函数默认构造函数可以是无参构造函数、全缺省构造函数但是在类B中找不到它的默认构造函数类B中显式的定义了一个有参构造函数那么我们就一定要传递实参才能调用类B中的有参构造函数。 对于初始化列表的再次理解之前我们写的很多代码都没有显式使用初始化列表初始化那么是否每个成员变量都被定义了呢 是的即使我们没有显式的使用初始化列表初始化成员变量但它一定是要通过初始化列表来定义的例如int a;这就叫做定义它为变量a开辟了4个字节大小的空间但是这块空间并没有显式的将某个值放到这块空间所以是随机值而对于int a 10;来说这就叫做初始化在开辟空间的同时显式的将10放到了这块空间。因此即使我们没有显式的在初始化列表中初始化成员变量但每个成员变量也是被定义的了从另外一个角度来说如果你没有定义成员变量那么你就没有空间没有空间那么一切都是徒劳的实际没有起任何作用 总结在以后我们尽量使用初始化列表初始化因为不管你是否使用初始化列表对于自定义类型成员变量一定会先使用初始化列表初始化。如果成员变量没有在初始化列表显式初始化对于内置类型有缺省值就用缺省值没有缺省值就是随机值对于自定义类型会去调用该自定义类型的默认构造函数如果没有默认构造函数就会报错 下面我们继续来看看初始化列表的性质大家来做做下面这道题
class A
{
public:A(int a):_a1(a),_a2(_a1){}void Print() {cout _a1 _a2endl;}
private:int _a2;int _a1;
};int main()
{A aa(1);aa.Print();return 0;
} A. 输出1 1
B.程序崩溃
C.编译不通过
D.输出1 随机值相信接下来的答案会让部分读者大吃一斤 我们发现_a2的值为随机值 这是成员变量在类中声明次序就是其在初始化列表中的初始化顺序与其在初始化列表中的先后次序无关。_a2先进行声明于是_a2先在初始化列表中进行初始化此时变量_a1为随机值那么变量_a2也就为随机值后对_a1变量进行显式初始化得到的就是1了。另外我尝试了一下在声明位置为变量_a1提供了缺省值但最终得出的答案是一样的这里我个人猜想是因为变量_a1与_a2都是在初始化列表中显式初始化因此根本用不上缺省值。 总结成员变量在类中声明次序就是其在初始化列表中的初始化顺序与其在初始化列表中的先后次序无关。
关于这个知识点大家也可以自行通过调试来观察初始化列表初始化的顺序。
二、explict关键字
构造函数不仅可以构造与初始化对象对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数还具有类型转换的作用。
单参数构造函数隐式类型转换C98
class A
{
public:A(int a): _a(a){cout A(int) endl;}A(const A a){cout A(const A) endl;}private:int _a;
};int main()
{A aa(1); // 拷贝构造A aa2 1; // 隐式类型转换这里由构造 拷贝直接优化成了构造const A ret 10; // 产生一个临时变量临时变量具有常属性需要const修饰int i 2; double d i; // 隐式类型转换int类型的变量i经过处理之后产生一个double类型临时变量由临时变量返回给dcout d endl;return 0;
}explicit 修饰构造函数禁止单参数隐式类型转换
如果我不想让自定义类型发生隐式类型转换我们可以在构造函数前加上explicit关键字禁止隐式类型转换。 多参数构造函数隐式类型转换C11
explicit 修饰构造函数禁止多参数隐式类型转换 关于这个关键字仅仅作为了解即可因为构造函数隐式类型转换在实际用的还是比较多的我们根据场合合理使用explicit关键字即可。
三、static成员
概念 声明为static的类成员称为类的静态成员用static修饰的成员变量称之为静态成员变量用static修饰的成员函数称之为静态成员函数。 注静态成员变量一定要在类外进行初始化。
3.1 特性 1.静态成员为所有类对象所共享不属于某个具体的对象存放在静态区 2.静态成员变量必须在类外定义定义时不添加 static 关键字类中只是声明 3.类静态成员即可用 类名::静态成员 或者 对象.静态成员来访问 4.静态成员函数没有隐藏的 this 指针不能访问任何非静态成员 5.静态成员也是类的成员受public、protected、private 访问限定符的限制 6.static 成员变量在对象生成之前生成 我们来看一道题请你实现一个类计算程序中创建出了多少个类对象
首先我们分析一个对象不是构造函数创建出来的就是拷贝构造函数创建出来的所以我们只需要统计调用构造函数和拷贝构造函数的次数就可以了。
#include iostream
using namespace std;int count 0;class A
{
public:A(int a 0){count;}A(const A a){count;}
};void Func(A a)
{}int main()
{A aa1;A aa2(aa1);Func(aa1);A aa3 1;cout count endl;return 0;
}要解决这个命名冲突问题一种方式是我们可以通过将这里的全局变量count重命名一下另外一种方式是可以不将std命名空间域全局展开将使用次数多的命名空间域的进行局部展开或者指定命名空间域即可这也就是之前我们讲过的为什么不推荐using namespace全局展开命名空间域的原因。 通过全局变量计数的方式就可以知道一个程序创建了多少个类对象但是这种方式不是很好。因为全局变量是可以随时改变的万一不小心改变了答案就出错了。C 是很注重数据的封装的利用static成员变量就能很好的解决这个问题。
#include iostream
using namespace std;class A
{
public:A(int a 0){count;}A(const A a){count;}//private:static int count; // 声明这里不能给缺省值因为缺省值是在构造函数初始化列表时使用的但是我们的count是静态成员它是共享的并不是某个特定对象的成员
};int A::count 0; // 定义初始化void Func(A a)
{}int main()
{A aa1;A aa2(aa1);Func(aa1);A aa3 1;cout A::count endl; // 通过类域找到静态成员cout aa2.count endl; // 通过对象访问静态成员cout aa3.count endl; // 同上A* ptr nullptr; // 同样的这里的ptr并没有进行解引用它是直接可以访问到count的cout ptr-count endl;return 0;
}我们解决了全局变量被修改的问题但static成员是公有的并没有起到封装作用我们该如何解决
我们可以定义一个函数得到static成员的值通过对象就可以调用函数得到静态成员的值了。 那么如果我们不想使用一个对象去调用函数而是直接调用这个函数呢这时候我们就可以使用static成员函数了
class A
{
public:A(int a 0){count;}A(const A a){count;}static int GetCount() // 静态成员函数它是没有this指针的因为它不属于某个特定的对象它是共享的{return count; // 静态函数内只能只用静态成员因为没有this指针所以不能去访问非静态成员我们平时都是隐式的使用this指针来访问非静态成员的}private:static int count; // 声明这里不能给缺省值因为缺省值是在构造函数初始化列表时使用的但是我们的count是静态成员它是共享的并不是某个特定对象的成员
};int A::count 0; // 定义初始化void Func(A a)
{}int main()
{A aa1;A aa2(aa1);Func(aa1);A aa3 1;cout A::GetCount() endl;return 0;
}静态成员函数的特性 1.静态成员函数是被所有类对象共享的放在静态区的。在类的外部使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化。 2.静态成员函数没有隐含this指针。 3.静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。 4.静态成员函数可以通过类名加范围解析运算符 :: 访问。 5.静态成员函数可以通过对象访问。 四、匿名对象
从字面意思上匿名对象就是没有名字的对象你可以理解为是一个临时对象一般是系统自动生成的。像我们以值的方式给函数传参、类型转换以及函数返回一个对象时都隐式的生成了一个匿名对象。
下面我们来看看匿名对象的简单用法
#include iostream
using namespace std;class A
{
public:A(int a 10):_a(a){cout this : A(int a) endl;}~A(){cout this : ~A() endl;}void Print(){cout this : _a endl;}private:int _a;
};A Func()
{return A(20);
}int main()
{A aa A(1); // 匿名对象赋值实例化对象A().Print(); // 匿名对象调用成员函数A(30); // 匿名对象调用构造函数Func(); // 匿名对象做返回值return 0;
}4.1 匿名对象的生命周期
关于匿名对象的用法是比较简单的最重要的是它的生命周期下面我们就来探究一下匿名对象的生命周期我们以上述代码的结果来进行分析 从上图我们发现匿名对象在外面没有对象等待被其实例化时调用完构造函数之后马上就会调用析构函数这是巧合吗并不是我们看向第一个实例化对象它是最后才被析构的而不是调用完构造之后立马析构。 除第一条代码之外其余生成的匿名对象在外面没有对象等待被其实例化此匿名对象的生命周期只有这一行将会在构造函数生成之后立马被析构而第一行代码正是由于生成的匿名对象在外部有对象等待被它实例化此匿名对象的生命周期就变成了外部对象的生命周期也就是在出了main函数之后才会被析构 总结如果生成的匿名对象在外面没有对象等待被其实例化此匿名对象的生命周期就只有这一行将会在调用构造函数之后立马析构如果生成的匿名对象在外部有对象等待被它实例化此匿名对象的生命周期就变成了外部对象的生命周期。 五、内部类 概念如果一个类定义在另一个类的内部这个内部类就叫做内部类。内部类是一个独立的类它不属于外部类更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。 注意内部类就是外部类的友元类参见友元类的定义内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性 1.内部类可以定义在外部类的 public、protected、private 都是可以的。 2.注意内部类可以直接访问外部类中的 static 成员不需要外部类的对象或类名。 3.sizeof(外部类) 外部类和内部类没有任何关系。 sizeof(外部类) 外部类
#include iostream
using namespace std;class A
{
public:class B // 内部类B天生就是外部类A的友元{int _b;};
private:int _a;
};int main()
{cout sizeof(A) endl;cout sizeof(A::B) endl;return 0;
}从结果上我们看到外部类A与内部类B的大小是一样的外部类A的大小为4这说明外部类A根本没有包括内部类成员它们两者是独立不同的两块空间。 注意外部类与内部类相当于两个不同的空间只是内部类的访问受外部类作用域和访问限定符的限制。 我们接着来继续看看内部类的特性
#include iostream
using namespace std;class A
{
private:static int k;int h 1;
public:class B // B天生就是A的友元所以类B能够访问类A的成员变量{public:void foo(const A a){cout k endl; //OKcout a.h endl; //OK}void Print(){cout hello world endl;}private:int _b;};
};int A::k 10; // 静态成员初始化int main()
{A::B b;b.foo(A());return 0;
}上述代码中类B是A的内部类天生是类A的友元(朋友)所以类B能够访问类A的成员但类A不能访问类B的成员。这里有一个形象的比喻你把你喜欢的人当朋友但是她拿你做备胎当ATM所以对于感情我们一定要学会理智不要当舔狗最后舔到一无所有
六、拷贝对象时编译器做的一些优化处理
在传参和传返回值的过程中一般比较新的编译器会做一些优化减少对象的拷贝这个在一些场景下还是非常有用的。
优化场景1函数传参
class A
{
public:A(int a 10): _a(a){cout this : A(int) endl;}A(const A a){cout this : A(const A) endl;}~A(){cout this : ~A() endl;}private:int _a;
};// 传值传参
void Func1(A aa)
{}// 传引用传参
void Func2(const A aa)
{}int main()
{A aa1 1; // 连续进行构造 拷贝构造 构造// 传值传参Func1(aa1); // 拷贝构造 未优化Func1(2); // 连续进行构造 拷贝构造 构造Func1(A(3)); // 构造 拷贝构造 构造cout ---------------------------------------- endl;// 传引用传参Func2(aa1); // 未进行任何对象的创建Func2(2); // 构造无拷贝构造 未优化Func2(A(3));// 构造无拷贝构造 未优化return 0;
}优化场景2对象返回
有些读者可能不清楚其中的构造、拷贝构造以及析构函数等的调用顺序这里我们每调用一次函数就打印当前对象的地址这样大家就能更加清楚整个过程。
#include iostream
using namespace std;class A
{
public:A(int a 10): _a(a){cout this : A(int) endl;}A(const A a){cout this : A(const A) endl;}~A(){cout this : ~A() endl;}A operator(const A d){cout this : operator(const A) endl;return *this;}private:int _a;
};A Func3()
{A aa;return aa;
}A Func4()
{return A();
}int main()
{Func3(); // 构造 拷贝构造// 拷贝构造方式接收返回对象A aa2 Func3(); // 构造 拷贝构造 拷贝构造 构造 拷贝构造cout ---------------------------------------- endl;// 赋值接收返回对象A aa3; // 构造aa3 Func3(); // 构造 拷贝构造 赋值拷贝 未优化cout ---------------------------------------- endl;// 返回匿名对象Func4(); // 构造 拷贝构造 构造A aa4 Func4(); // 构造 拷贝构造 构造 构造拷贝 构造return 0;
}总结 对象返回 1.接收返回值对象尽量拷贝构造函数接收不要赋值接收 2.函数返回对象时尽量返回匿名对象 函数传参 1.尽量使用const 传参 七、再次理解类和对象
在类和对象阶段大家一定要体会到类是对某一类实体(对象)来进行描述的描述该对象具有那些属性那些方法描述完成后就形成了一种新的自定义类型才用该自定义类型就可以实例化具体的对象。
