类和对象

一.初始化列表面试题

二.隐式类型转换与explicit三.静态成员——static四.友元五.内部类六.匿名对象七.对象拷贝时的编译器优化

一.初始化列表

之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方式，就是初始化列表，初始化列表的使用方式是以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。<code>每个构造函数都有初始化列表。

引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会编译报错。

C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。

尽量使用初始化列表初始化，因为不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。

初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持一致。

#include<iostream>

using namespace std;

class Time

{ -- -->

public:

// 默认构造

Time(int hour = 0)

:_hour(hour)

{

cout << "Time()" << endl;

}

private:

int _hour;

};

class Date

{

public:

Date(int& xx, int year, int month, int day)

:_year(year)

,_month(month)

,_day(day)

,_ptr((int*)malloc(12))

,_n(100)

,_ref(xx)

,_t(1)//初始化列表：成员变量定义的地方

{

//初始化列表与函数体可以配合使用

if (_ptr == nullptr)

{

perror("malloc fail!");

}

else

{

memset(_ptr, 0, 12);

}

}

void Print() const

{

cout << _year << "/" << _month << "/" << _day << endl;

}

private:

// 声明未开空间 可以在函数内部初始化，也可以在初始化列表中初始化

int _year = 1; //C++11 中的缺省值——>初始化列表用的

int _month;

int _day;

int* _ptr;

// 必须在定义的地方（初始化列表）中初始化

const int _n;

int& _ref;

Time _t; //即使初始化列表没有_t，也会调用Time的默认构造

};

int main()

{

int xx = 200;

//对象定义，对象中的成员在初始化列表中定义

Date d1(xx, 2024, 7, 20);

d1.Print();

return 0;

}

面试题

<code>#include<iostream>

using namespace std;

class A

{ -- -->

public:

A(int a)

:_a1(a)

,_a2(_a1)

{ }

void Print() {

cout << _a1 << " " << _a2 << endl;

}

private:

int _a2 = 2; //先声明的先在初始化列表中定义，由于_a1是随机值，所以_a2就是随机值

int _a1 = 2; //再就是实参1传给_a1，_a1就是1

};

int main()

{

A aa(1);

aa.Print();//打印 1 随机值

return 0;

}

有一个类A，其数据成员如下： 则构造函数中，成员变量一定要通过初始化列表来初始化的是：bc

class A

{

private:

int a;

public:

const int b;

float*& c;

static const char* d; //静态成员类内声明，类外初始化

static double* e;

};

二.隐式类型转换与explicit

C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。

构造函数前面加explicit就不再支持隐式类型转换。

#include<iostream>

using namespace std;

class A

{

public:

//构造函数explicit就不再支持隐式类型转换

//explicit A(int a1)

A(int a1)

{

_a1 = a1;

}

//explicit A(int a1, int a2)

A(int a1, int a2)

{

_a1 = a1;

_a2 = a2;

}

A(const A& a)

{

_a1 = a._a1;

_a2 = a._a2;

}

void Print()

{

cout << _a1 << " " << _a2 << endl;

}

private:

int _a1;

int _a2;

};

int main()

{

A a1(1);// 调用有参构造函数

a1.Print();

//单参数构造函数支持：隐式类型转换

//2构造一个A的临时对象，再用这个临时对象拷贝构造a2

//编译器遇到：构造+拷贝构造——>优化为：直接构造

A a2 = 2;

a2.Print();

int i = 1;

double d = i;

//const修饰引用

A& ra1 = a1;

//A& ra1 = 2; 权限放大：临时对象具有常性

const A& ra1 = 2; //构造临时对象，但不存在拷贝构造（引用）

int i = 1;

double d = i;

//double& rd = i; 权限放大：临时对象具有常性

const double& rd = i;

return 0;

}

<code>#include<iostream>

using namespace std;

class A

{ -- -->

public:

A(int a1 = 0)

{

_a1 = a1;

}

void Print()

{

cout << _a1 << endl;

}

private:

int _a1;

};

class Stack

{

public:

void Push(const A& a)

{

//...

}

private:

A _arr[10];

int _top;

};

int main()

{

Stack st;

A a1(1);

st.Push(a1);

//直接传入常量

st.Push(3);

return 0;

}

<code>#include<iostream>

using namespace std;

class A

{ -- -->

public:

A(int a1 = 0, int a2 = 0)

:_a1(a1)

, _a2(a2)

{ }

void Print()

{

cout << _a1 << endl;

}

private:

int _a1;

int _a2;

};

class Stack

{

public:

void Push(const A& a)

{

//...

}

private:

A _arr[10];

int _top;

};

int main()

{

Stack st;

//C++11支持传入多个参数进行隐式类型转换

A a1 = { 1,1 };

A& ra1 = a1;

st.Push(ra1);

//等价于

st.Push({ 1,1 });

//A& ra1 = { 2,2 }; error

const A& ra1 = { 2,2 };

return 0;

}

三.静态成员——static

用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。

静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。

用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。

静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。

非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。

静态成员也是类的成员，受public、protected、private访问限定符的限制。

静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

#include<iostream>

using namespace std;

class A

{

public:

A()

{

++_scount;

}

A(const A& t)

{

++_scount;

}

~A()

{

--_scount;

}

//静态成员函数：没有默认的this指针

static int GetACount()

{

// _a++; 由于没有this指针，无法操作非静态成员变量

return _scount;

}

private:

// 类里面声明

static int _scount;

int _a;

};

// 类外面初始化

int A::_scount = 0;

int main()

{

//cout << A::_scount << endl; //若_scount访问权限为public，可以通过指定类域访问

//cout << sizeof(A) << endl; //1

//指定类域调用静态成员函数

cout << A::GetACount() << endl; //0

A a1, a2;

{

A a3(a1);

cout << A::GetACount() << endl; //3

//该域结束a3就销毁了，调用析构函数

}

//两种方式调用静态成员：指定类域静态成员/对象.静态成员

cout << A::GetACount() << endl; //2

cout << a1.GetACount() << endl; //2

return 0;

}

设已经有A、B、C、D，4个类的定义：

C c;

int main()

{

A a;

B b;

static D d; //声明周期为全局，先析构局部变量，先定义的后析构，再析构全局变量

return 0；

}

程序中A,B,C,D构造函数调用顺序为：C、A、B、D

程序中A,B,C,D析构函数调用顺序为：B、A、D、C

求1+2+3+…+n

class Sum

{

public:

Sum()

{

_sum+=_i;

_i++;

}

static int GetSum()

{

return _sum;

}

private:

static int _i;

static int _sum;

};

int Sum::_i = 1;

int Sum::_sum = 0;

class Solution

{

public:

int Sum_Solution(int n)

{

//Sum a[n];

Sum* p = new Sum[n];

delete [] p;

return Sum::GetSum();

}

};

四.友元

友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到⼀个类的里面。

外部友元函数可访问类的私有和保护成员但是不允许修改，友元函数仅仅是⼀种声明，他不是类的成员函数。

友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

一个函数可以是多个类的友元函数。

#include<iostream>

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;

}

友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。

#include<iostream>

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的友元。

有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

五.内部类

如果一个类定义在另一个类的内部，这个类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。

内部类默认是外部类的友元类。

内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。

#include<iostream>

using namespace std;

class A

{

private:

static int _k;

int _h = 1;

public:

class B //B默认是A的友元：B可以访问A的私有成员

{

public:

void func(const A& a)

{

cout << _k << endl;

cout << a._h << endl;

}

private:

int _b = 1;

};

};

int A::_k = 1;

int main()

{

cout << sizeof(A) << endl; //4字节

A::B b; //必须指定类域定义b，无法用B b;

A aa;

b.func(aa);

return 0;

}

求1+2+3+…+n

class Solution {

public:

class Sum

{

public:

Sum()

{

sum+=i;

i++;

}

};

int Sum_Solution(int n)

{

//Sum a[n];

Sum* a = new Sum[n];

delete [] a;

return sum;

}

private:

static int i;

static int sum;

};

int Solution::i = 1;

int Solution::sum = 0;

六.匿名对象

用类型(实参)定义出来的对象叫做匿名对象，相比之前我们定义的类型 对象名(实参)定义出来的叫有名对象。

匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

#include<iostream>

#include<algorithm> //算法的头文件

using namespace std;

class A

{

public:

A(int a = 0)

:_a(a)

{

cout << "A(int a)" << endl;

}

~A()

{

cout << "~A()" << endl;

}

private:

int _a;

};

class Solution

{

public:

int Sum_Solution(int n)

{

//...

return n;

}

};

bool myfunction(int i, int j)

{

return i > j;

}

int main()

{

A aa1; //有名对象

// A aa2(); 错误：无法区分函数声明与定义对象

// 匿名对象的生命周期为当前一行

A(); //匿名对象

A(1);

Solution st;

cout << st.Sum_Solution(10) << endl;

//这样更方便

cout << Solution().Sum_Solution(10) << endl;

int a[] = { 5,3,6,9,8,4,2,1,7 };

//升序<

sort(a, a + 9);

//降序>

sort(a, a + 9, myfunction);

greater<int> gt;

sort(a, a + 9, gt);

sort(a, a + 9, greater<int>());//匿名对象

return 0;

}

七.对象拷贝时的编译器优化

了解就行：

现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会尽可能减少一些传参和传返回值过程中可以省略的拷贝。

如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新更"激进"的编译还会进行跨行跨表达式的合并优化。

#include<iostream>

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& operator++()

{

++_a1;

return *this;

}

~A()

{

cout << "~A()" << endl;

}

void Print()

{

cout << "Print()——>" << _a1 << endl;

}

private:

int _a1 = 1;

};

void f1(A aa)

{

}

//传值传参

void main1()

{

//隐式类型转换，连续的 构造+拷贝构造->优化为直接构造

A aa1 = 1;

//只是直接构造，无需优化

const A& aa2 = 1;

//不连续的表达式不会优化

A aa3(1); //构造

f1(aa3); //拷贝构造，若用f1函数引用接收，就不会调用拷贝构造

//隐式类型转换，连续的 构造+拷贝构造->优化为直接构造

f1(1);

f1(A(2));//匿名对象，连续的 构造+拷贝构造->优化为直接构造

//总结：一个表达式中，连续的 构造+拷贝构造->优化为直接构造

}

/

A f2()

{

//本质：先构造aa，由于函数时结束时销毁aa，所以再拷贝构造一个临时对象

A aa(1); //构造

++aa;

return aa; //返回拷贝构造的临时对象

}

A f3()

{

A aa(1);

return aa;

}

//传值返回

void main2()

{

//将构造aa，拷贝构造临时对象——>优化为：直接构造临时对象（vs2022）

f2().Print();

cout << "*****" << endl << endl;

//连续的 构造+拷贝构造+拷贝构造->优化为：直接构造（vs2022）

A ret = f3();

ret.Print();

cout << "*****" << endl << endl;

//以下编译器不做优化

A ret1;

ret1 = f3(); //注意：这是赋值并非拷贝构造

ret1.Print();

cout << "*****" << endl << endl;

}

int main()

{

main1();

main2();

return 0;

}