wordpress恢复主题,wordpress博客seo优化插件,中国搜索引擎排名2021,2023新闻摘抄大全文章目录 前言一. 再探构造函数初始化列表特性总结练习 二. 类型转换2.1 隐式类型转换2.2 临时对象具有常性2.3 explicit关键字2.4 多参数类型转化 三. static成员概念特性练习 四. 友元概念特性 五. 内部类概念特性 六. 匿名对象概念特性 七. 对象拷贝时的编译器优化END 前言 … 文章目录 前言一. 再探构造函数初始化列表特性总结练习 二. 类型转换2.1 隐式类型转换2.2 临时对象具有常性2.3 explicit关键字2.4 多参数类型转化 三. static成员概念特性练习 四. 友元概念特性 五. 内部类概念特性 六. 匿名对象概念特性 七. 对象拷贝时的编译器优化END 前言
在学习C类和对象上和中的基础上我们继续来学习C类和对象剩下的内容大致包括构造函数的初始化列表隐式类型转换static成员友元内部类匿名对象对象拷贝时编译器的优化。
一. 再探构造函数
初始化列表
之前我们实现构造函数时初始化成员变量主要使用函数体内赋值构造函数初始化还有一种方式就是初始化列表。
初始化列表的使用方式是以一个冒号开始接着是一个以逗号分隔的数据成员列表每个成员变量后面跟一个放在括号中的初始值或表达式。而函数体可以实现其它功能。
class Date
{
public:Date(int year, int month, int day):_year(year),_month(month),_day(day){cout _year / _month / _day endl;}
private:int _year;int _month;int _day;
};对于自定义类型的成员编译器自动调用它的默认构造函数初始化列表可以不显示写。但是当这个自定义类型的成员没有默认的构造函数时我们需要在初始化列表显示调用它的构造函数否则就会报错。
#includeiostream
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout Time() endl;}
private:int _hour;
};
class Date
{
public:Date(int year 1, int month 1, int day 1):_year(year),_month(month),_day(day),_t(10){}void Print() const{cout _year / _month / _day endl;}
private:int _year;int _month;int _day;Time _t; //没有默认构造函数
};
int main()
{Date d1;d1.Print();return 0;
}可以看到类Time没有默认构造函数所以我们需要手动在初始化列表里调用类对象_t的构造函数来实现初始化。如果不写就会报错如下 特性
1.每个成员变量在初始化列表中只能出现一次语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。
当有成员变量在初始化列表出现两次就会报错如下
2.引用成员变量const成员变量没有默认构造的类类型变量必须放在初始化列表位置进行初始化否则会编译报错。
#includeiostream
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout Time() endl;}
private:int _hour;
};
class Date
{
public:Date(int x, int year 1, int month 1, int day 1):_year(year),_month(month),_day(day),_t(10),_i(x),j(1){}void Print() const{cout _year / _month / _day endl;}
private:int _year;int _month;int _day;Time _t; //没有默认构造的类类型变量int _i; //引用类型变量const int j; //const成员变量
};
int main()
{int i 0;Date d1(i);d1.Print();return 0;
}如果不放在初始化列表进行初始化就会发生如下报错 3.C11支持在成员变量声明的位置给缺省值这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
#includeiostream
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout Time() endl;}
private:int _hour;
};
class Date
{
public:Date(int x):_i(x){}void Print() const{cout _year / _month / _day endl;}
private:// 注意这里不是初始化这里给的是缺省值这个缺省值是给初始化列表的// 如果初始化列表没有显示初始化默认就会用这个缺省值初始化int _year 2024;int _month 11;int _day 4;Time _t 10;int _i;const int j 1;
};
int main()
{int i 0;Date d1(i);d1.Print();return 0;
}通过调试可以看出当在成员变量声明时给缺省值这个缺省值会给到初始化列表如果没有在初始化列表里初始化成员变量编译器会自动调用缺省值去初始化成员变量。 尽量使用初始化列表初始化因为那些不在初始化列表初始化的成员也会走初始化列表如果这个成员在声明位置给了缺省值初始化列表会用这个缺省值初始化。如果没有给缺省值对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器C并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员的默认构造函数如果没有默认构造会编译错误。 5.初始化列表中按照成员变量在类中声明顺序进行初始化跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持一致。
#includeiostream
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout Time() endl;}
private:int _hour;
};
class Date
{
public:Date(int x):_i(x),_t(10),_month(11),_year(2024),_day(4){}void Print() const{cout _year / _month / _day endl;}
private:int _year;int _month;int _day;Time _t;int _i;
};
int main()
{int i 0;Date d1(i);d1.Print();return 0;
}进入调试可以知道编译器不是按照成员在初始化列表出现的顺序来对成员进行初始化的而是按照成员在类中声明的顺序。
总结 无论是否显示写初始化列表每个构造函数都有初始化列表 无论是否在初始化列表显示初始化每个成员变量都要走初始化列表初始化 练习
#includeiostream
using namespace std;
class A
{
public:A(int a):_a1(a), _a2(_a1){}void Print() {cout _a1 _a2 endl;}
private:int _a2 2;int _a1 2;
};
int main()
{A aa(1);aa.Print();return 0;
}这段程序的运行结果是什么呢我们先来看结果 这里有以下需要注意的地方 1.成员变量在声明时给的值是缺省值这个缺省值是给初始化列表的不是初始化成员的。如果成员变量在初始化列表里显示初始化了这个缺省值就不需要了否则就用这个缺省值来对成员变量进行初始化。 2.初始化列表中按照成员变量在类中声明顺序进行初始化跟成员在初始化列表出现的的先后顺序无关 因为_a1和_a2都是int类型(内置类型)所以编译器一开始不做处理_a1和_a2都是随机值。类A的初始化列表先初始化_a2_a2初始化为_a1所以_a2还是随机值然后再初始化_a1_a1初始化为形参a所以_a1初始化为1。
二. 类型转换
2.1 隐式类型转换
C支持内置类型隐式类型转换为类类型对象需要有相关内置类型为参数的构造函数。隐式类型转换也称为类型强制转换涉及将一种类型的对象转换为另一个类型的对象而不需要显示地使用类型转换运算符。这种转换通常通过类的单参数构造函数来实现这种构造函数被称为转换构造函数。
例如
class MyClass {
public: MyClass(int value) { // 转换构造函数 // 用于将 int 类型转换为 MyClass 类型 }
};#includeiostream
using namespace std;
class A
{
public:A(int a):_a(a){cout A(int a) endl;}A(const A aa){_a aa._a;_b aa._b;cout A(const A aa) endl;}void Print() {cout _a _b endl;}
private:int _a;int _b 1;
};
int main()
{// 1构造⼀个A的临时对象再用这个临时对象拷贝构造aa// 编译器遇到连续构造拷贝构造-优化为直接构造A aa 1;aa.Print();return 0;
}A aa 1 这种将整数类型赋值给自定义类型有着明显的逻辑错误但是类A实现了单个(整数)参数的构造函数所以编译器调用类A的转换构造函数 A(int a) 来创建一个 A 类型的临时对象这个临时对象是通过调用 A(1) 来构造的。最后通过调用 aa 的拷贝构造函数来实现 aa 对临时对象的拷贝。 注意在C11及以后的版本中C编译器可能会应用返回值优化或命名返回值优化来避免不必要的临时对象创建和拷贝。这样就不会调用拷贝构造函数编译器可以直接在目标对象的内存位置构造对象而不是先创建一个临时对象再进行拷贝。
当编译器进行优化为直接构造时对于创建对象aa的过程如下 1.识别到A aa 1;这一语句需要将整数 1 转换为A类型对象。 2.编译器直接在aa对象的内存位置调用构造函数A(int a)将参数 1 传入该构造函数。 3.构造函数内部将参数 1 赋值给成员变量_a并根据默认初始化规则初始化成员变量_b如果没有显式指定初始值_b会按照其类型进行默认初始化。 4.这样就完成了对aa对象的构造整个过程没有临时对象的创建和调用拷贝构造函数。 注意如果编译器进行优化为直接构造通常相当于没有临时对象创建但整数 1 仍然会隐式转换为 A 类型对象。 因为即使是直接在目标对象的内存位置构造对象编译器在识别到需要将整数转换为 A 类型对象时仍然会调用接受一个整数参数的构造函数 A(int a)来进行类型转换操作。这个过程本质上还是隐式类型转换只是编译器可能避免了创建临时对象和调用拷贝构造函数的额外开销。 2.2 临时对象具有常性 在上述例子中如果尝试用A类型对象对整数1进行引用编译器会报错。因为当整数1隐式类型转换为A类型的临时对象后该临时对象具有常性如果用非常量引用去引用该临时对象会导致权限的放大从而导致编译器报错。
当使用const修饰引用时(const引用)编译器就不会报错。
#includeiostream
using namespace std;
class A
{
public:A(int a):_a(a){}//因为打印函数不用改变对象的成员变量所以这里最好使用const修饰this指针指向的对象//这样就防止通过this指针去修改对象的成员//也防止了常量对象调用Print函数时造成权限放大而导致编译器报错void Print() const{cout _a _b endl;}
private:int _a;int _b 1;
};
int main()
{const A aa 1;aa.Print();return 0;
}内置类型的类型转换
当内置类型发生类型转换时也会生成临时对象引用该临时对象必须使用const引用const 引用绑定到临时对象后会延长该临时对象的生命周期。
#includeiostream
using namespace std;
int main()
{int i 1;double d i;// 不报错整数i隐式类型转换为double类型再赋值给d//double d1 i;// 报错i创建了一个double类型的临时对象临时对象具有常性导致权限放大编译器报错const double d2 i;// 不报错权限的平移return 0;
}类类型的类型转换
类类型的对象之间也可以隐式转换需要相应的构造函数支持。比如整数1转换为类类型对象需要单参数(整数)的构造函数同理类类型对象之间的相互转换(A类型转换为B类型)也需要单参数(A类型对象)的构造函数。
#includeiostream
using namespace std;
class A
{
public:A(int a1):_a1(a1){}void Print(){cout _a1 _a2 endl;}int Get() const{return _a1 _a2;}
private:int _a1 1;int _a2 2;
};
class B
{
public://使用const引用减少拷贝同时不会修改源对象的成员B(const A a):_b(a.Get()){}
private:int _b 0;
};
int main()
{A aa 1;A aa1 2;// aa隐式类型转换为b对象// 原理跟上面类似B b aa;const B rb aa1;// aa1创建了一个B类型的临时对象因为临时对象具有常性所以要使用const引用return 0;
}2.3 explicit关键字
构造函数前面加explicit就不再支持隐式类型转换。
explicit A(int a):_a1(a), _a2(_a1)
{}当整数1转换为A类型对象时会调用构造函数A(1)但是构造函数前面加了explicit关键字使得整数1不能隐式地进行类型转换。
2.4 多参数类型转化
多参数的类型转换需要有相对应的多参数构造函数才能实现。C11之后才支持多参数转化。
多参数的类型转换需要使用花括号 { }
#includeiostream
using namespace std;
class A
{
public:A(int a1):_a1(a1){}A(int a1, int a2):_a1(a1), _a2(a2){}void Print(){cout _a1 _a2 endl;}int Get() const{return _a1 _a2;}
private:int _a1 1;int _a2 2;
};
int main()
{// C11之后才支持多参数转化A aa3 { 2,2 };return 0;
}同样地若多参数构造函数不期望支持隐式类型转换只需在构造函数前面加上explicit关键字即可
三. static成员
概念
static 成员即静态成员是编程中面向对象编程语言中的一个概念它属于类而不是类的某个特定实例对象。
特性
用static修饰的成员变量称之为静态成员变量静态成员变量一定要在类外进行初始化。
#includeiostream
using namespace std;
class A {
public://静态成员不能在类里面初始化/*A(int i 1):_a(i){}*/void Print() const{cout _a endl;}
private:static int _a;
};
int A::_a 1;
int main()
{A aa;aa.Print();return 0;
}非静态成员变量不能在类的外部定义 静态成员变量为所有类对象所共享不属于某个具体的对象不存在对象中存放在静态区。 用static修饰的成员函数称之为静态成员函数静态成员函数没有this指针不能访问非静态成员变量。
#includeiostream
using namespace std;
class A {
public://静态成员不能在类里面初始化/*A(int i 1):_a(i){}*/void Print() const{cout _a endl;}/*static int get(){return _b;//静态成员函数没有this指针不能访问非静态成员变量}*/
private:static int _a;int _b;
};
int A::_a 1;
int main()
{A aa;aa.Print();return 0;
}静态成员函数中可以访问其他的静态成员但是不能访问非静态的因为没有this指针。非静态的成员函数可以访问任意的静态成员变量和静态成员函数。突破类域就可以访问静态成员可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。
#includeiostream
using namespace std;
class A {
public:void Print() const{cout _a _b endl;}static int get(){return _a;}
public:static int _a;
private:int _b 2;
};
int A::_a 1;
int main()
{A aa;cout A::_a endl;cout aa._a endl;cout A::get() endl;cout aa.get() endl;return 0;
}静态成员也是类的成员受public、protected、private访问限定符的限制。 可以看到不管是静态成员变量还是静态成员函数它们都受public、protected、private访问限定符的限制。 静态成员变量不能在声明位置给缺省值初始化因为缺省值是给构造函数初始化列表的静态成员变量不属于某个对象不走构造函数初始化列表。 练习
设已经有A,B,C,D 4个类的定义程序中A,B,C,D 4个类的构造函数和析构函数的调用顺序是什么
#includeiostream
using namespace std;
class A {
public:A(int i 1):a(i){cout A() endl;}~A(){cout ~A() endl;}
private:int a;
};
class B {
public:B(int i 1):b(i){cout B() endl;}~B(){cout ~B() endl;}
private:int b;
};
class C {
public:C(int i 1):c(i){cout C() endl;}~C(){cout ~C() endl;}
private:int c;
};
class D {
public:D(int i 1):d(i){cout D() endl;}~D(){cout ~D() endl;}
private:int d;
};
C c;
int main()
{A a;B b;static D d;return 0;
}我们先来看结果
构造函数的调用顺序全局区域——局部区域在局部区域不管是静态对象还是非静态对象谁先调用构造就先构造谁
析构函数的调用顺序局部区域——静态区——全局区域在局部区域后构造的先析构
四. 友元
概念
在C中友元friend是一种特殊的类成员或函数它不属于类的成员但可以访问类的私有private和保护protected成员。友元提供了一种机制使得某些特定的函数或类可以访问类的内部数据即使这些数据是私有的或受保护的。
友元提供了一种突破类访问限定符封装的方式友元分为友元函数和友元类在函数声明或者类声明的前面加 friend并且把友元声明放到一个类的里面。
友元函数一个非成员函数可以被声明为某个类的友元这样它就可以访问该类的所有私有和保护成员。友元函数的声明通常放在类的内部但定义通常在类定义之外。
class MyClass {
private:int privateVar;
public:void setPrivateVar(int value) { privateVar value; }friend void myFriendFunction(MyClass obj);
};void myFriendFunction(MyClass obj) {// 可以访问obj的私有成员obj.privateVar 10;
}友元类一个类可以被声明为另一个类的友元这样友元类的所有成员函数都可以访问声明它的类的私有和保护成员。
class MyClass {
private:int privateVar;
public:friend class MyFriendClass;
};class MyFriendClass {
public:void accessPrivateVar(MyClass obj) {// 可以访问obj的私有成员obj.privateVar 20;}
};特性
外部友元函数可访问类的私有和保护成员友元函数仅仅是一种声明他不是类的成员函数。
#includeiostream
using namespace std;class A
{// 友元声明friend void func(const A aa);
private:int _a1 1;int _a2 2;
};void func(const A aa)
{cout aa._a1 aa._a2 endl;
}int main()
{A aa;func(aa);return 0;
}友元函数可以在类定义的任何地方声明不受类访问限定符限制。一个函数可以是多个类的友元函数。
#includeiostream
using namespace std;// 前置声明否则A的友元函数声明时编译器不认识B
class B;class A
{// 友元声明friend void func(const A aa, const B bb);
private:int _a1 1;int _a2 2;
};class B
{// 友元声明friend void func(const A aa, const B bb);
private:int _b1 3;int _b2 4;
};void func(const A aa, const B bb)
{cout aa._a1 endl;cout bb._b1 endl;
}
int main()
{A aa;B bb;func(aa, bb);return 0;
}友元类中的成员函数都可以是另一个类的友元函数都可以访问另一个类中的私有和保护成员。
#includeiostream
using namespace std;
class A
{// 友元声明friend class B;
private:int _a1 1;int _a2 2;
};
class B
{
public:void func1(const A aa){cout aa._a1 endl;cout _b1 endl;}void func2(const A aa){cout aa._a2 endl;cout _b2 endl;}
private:int _b1 3;int _b2 4;
};
int main()
{A aa;B bb;bb.func1(aa);bb.func2(aa);return 0;
}友元类的关系是单向的不具有交换性比如A类是B类的友元但是B类不是A类的友元。友元类关系不能传递如果A是B的友元B是C的友元但是A不是C的友元。友元有时提供了便利。但是友元会增加耦合度破坏了封装所以友元不宜多用。
五. 内部类
概念
如果一个类定义在另一个类的内部这个在类内部的类就叫做内部类。内部类是一个独立的类跟定义在全局相比他只是受外部类类域限制和访问限定符限制所以外部类定义的对象中不包含内部类。
定义方式内部类定义在外部类的内部就像外部类的成员一样。
#includeiostream
using namespace std;
class A {
public:class B {private:int _i 3;int _j 4;};
private:int _i 1;int _j 2;
};
int main()
{cout sizeof(A) endl;return 0;
}特性
内部类默认是外部类的友元类。内部类可以直接访问外部类的公共、保护和私有成员。外部类则不是内部类的友元。
#includeiostream
using namespace std;
class A
{
private:int _q 2;int _h 1;
public:class B // B默认就是A的友元{public:void foo(const A a){cout a._q endl;cout a._h endl;}};
};
int main()
{//因为类B在类A里面受到类域的限制要实例化出一个B类型的对象必须突破类域//需要使用域作用限定符::A::B b;A aa;b.foo(aa);return 0;
}内部类可以直接访问外部类的静态成员变量。
#includeiostream
using namespace std;
class A
{
private:static int _k;int _h 1;
public:class B // B默认就是A的友元{public:void foo(const A a){cout a._k endl;cout a._h endl;}//可以直接访问外部类的静态成员变量void print(){cout _k endl;}};
};
int A::_k 1;
int main()
{cout sizeof(A) endl;A::B b;A aa;b.foo(aa);b.print();return 0;
}内部类本质也是一种封装当A类跟B类紧密关联A类实现出来主要就是给B类使用那么可以考虑把A类设计为B的内部类如果内部类使用访问限定符修饰private/protected那么A类就是B类的专属内部类其他地方都用不了。
六. 匿名对象
概念
在C中匿名对象通常指的是没有名字的对象。这种对象通常是临时的并且只在创建它们的表达式中有效。
用类型(实参)定义出来的对象叫做匿名对象相比之前我们定义的类型对象名(实参)定义出来的叫有名对象。
#includeiostream
using namespace std;
class A
{
public:A(int i 1):_a(i){cout A(int i) endl;}~A(){cout ~A() endl;}private:int _a;
};
int main()
{A a;A();return 0;
}特性
匿名对象生命周期只在当前一行当编译器读到下一行代码时匿名对象就会被自动销毁。一般临时定义一个对象当前用一下即可就可以定义匿名对象。 匿名对象可以调用它的成员函数
#includeiostream
using namespace std;
class A
{
public:A(int i 1):_a(i){cout A(int i) endl;}~A(){cout ~A() endl;}int Get(int n){return n;}private:int _a;
};
int main()
{cout A().Get(10) endl;return 0;
}匿名对象可以作为参数传递给函数
#includeiostream
using namespace std;
class A
{
public:A(int i 1):_a(i){cout A(int i) endl;}~A(){cout ~A() endl;}int Get(int n){return n;}private:int _a;
};
void Func(A a)
{}
int main()
{Func(A());return 0;
}同时匿名对象也可以作为函数参数的缺省值
void Func(A a A())
{}匿名对象的引用 匿名对象是临时的具有常性想引用一个匿名对象时必须使用const引用(权限的平移)。使用const引用我们可以确保引用不会修改源对象同时延长了对象的生命周期使其在整个程序运行期间都有效。这是因为const引用本身不会创建新的存储空间而是直接引用原始对象。 #includeiostream
using namespace std;
class A
{
public:A(int i 1):_a(i){cout A(int i) endl;}~A(){cout ~A() endl;}int Get(int n){return n;}private:int _a;
};
int main()
{A aa;const A a A();cout ---------- endl;return 0;
}可以看到通过const引用了一个匿名对象const绑定到了匿名对象上使其生命周期延长所以匿名对象不会被立马销毁。
如果不使用const引用编译器就会报错如下
七. 对象拷贝时的编译器优化 1.现代编译器会为了尽可能提高程序的效率在不影响正确性的情况下会尽可能减少一些传参和传返回值的过程中可以省略的拷贝。 2.如何优化C标准并没有严格规定各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化有些更新更激进的编译器还会进行跨行跨表达式的合并优化。 #includeiostream
using namespace std;
class A
{
public:A(int a 0):_a1(a){cout A(int a) endl;}A(const A aa):_a1(aa._a1){cout A(const A aa) endl;}A operator(const A aa){cout A operator(const A aa) endl;if (this ! aa){_a1 aa._a1;}return *this;}~A(){cout ~A() endl;}
private:int _a1 1;
};void f1(A aa)
{}
A f2()
{A aa;//cout aa endl;return aa;
}
int main()
{//vs2019: 1构造一个临时对象A(1),临时对象再拷贝构造aa1此时1隐式类型转换为临时对象//vs2022: 此时1隐式类型转换为临时对象A(1)相当于A aa1 A(1);//为了避免拷贝编译器优化为直接构造aa1调用A aa1(1);A aa1 1;//传递实参aa1拷贝构造aaf1(aa1);cout endl;f1(1);// 隐式类型转换f1(A(1));// 显示调用传匿名对象cout endl;//vs2019: 构造拷贝构造//vs2022: 直接构造直接构造临时对象A()f2();cout endl;//vs2019: 连续拷贝构造拷贝构造-优化为一个拷贝构造//vs2022: 直接优化为直接构造f2()中的aa不构造构造aa2并且aa是aa2的别名//aa和aa2的地址一样(在同一块内存空间)aa不会随着f2()的销毁而被析构A aa2 f2();//cout aa2 endl;cout endl;//vs2019: 遇到连续拷贝构造赋值重载-无法优化//vs2022: f2()可优化直接构造赋值重载无法优化aa1 f2();cout endl;return 0;
}vs2019编译器(Debug)
vs2022编译器(Debug) 可以看到版本越新的编译器优化得越好。
END
对以上内容有异议或者需要补充的欢迎大家来讨论
