类和对象（下）

文章目录

• 1、构造函数补充
• • 初始化列表
• 2、类型转换
• 3、static成员
• 4、匿名对象
• 5、友元
• 6、内部类
• 7、对象拷贝时的编译器优化

1、构造函数补充

初始化列表

之前对类的成员初始化是在函数体内实现，但严格意义上来说，这不是初始化，而是赋初值。要想对成员进行真正的初始化，就需要使用初始化列表。 格式：固定格式,初始化列表必须写在构造函数的参数列表之后、函数体的左大括号 { 之前，并且以冒号 : 开头，结尾无 ; 。

构造函数 :成员1(表达式1或值1), 成员2(表达式2或值n), … 成员n(表达式n或值n) { //… }

注意事项：

#include<iostream>
using namespace std;

class A {
public:
//构造函数
A(int b)
:_b(b)
,_a(_b)//先初始化
{}

//打印成员
void Print()
{
cout << "_a->" << _a << " _b->" << _b << endl;
}
private:
int _a;//先初始化
int _b;
};
int main()
{
A a(1);
a.Print();
return 0;
}

class A {
public:
A(int a)
{

}

void Print()
{
cout << _a << endl;
}

private:
int _a = 3;
};

int main()
{
A a(1);
a.Print();

return 0;
}

（1） 引用成员变量

class A{
public:
A(int& a)
:_a(a)
{}
private:
int& _a;
};

（2）const成员变量

class A{
public:
A(int b)
:_b(b)
{}
private:
const int _b;
};

（3）没有默认构造的类类型变量

class A {
public:
A(int a)//显示定义构造函数
{
_a = a;
}
private:
int _a = 1;
};

class B {
public:
B()
:_c(1)
{}
private:
A _c;
};

5.一个类，无论成员在不在初始化列表初始化，无论有没有初始化，调用该类时编译器都会在初始化列表走改成员初始化。如果该成员是内置有缺省值用缺省值，没有则给随机值；如果该成员是自定义类型，有默认构造走默认构造，没有就报错。

2、类型转换

class A {
public:
A(int a)
:_a(a)
{
}
private:
int _a;
};

class B {
public:
B(int a,int b)
{ }
private:
int _a;
int _b;
};

int main()
{
//单参数转换
A a = 1;

//多参数转换
B b = { 1,2 };
return 0;
}

class A {
public:
A(int a)
:_a(a)
{ }
void Print()
{
cout << _a << endl;
}
private:
int _a;
};

int main()
{
A a = 1;

A b = a;//a隐式转换为int类型

b.Print();
return 0;
}

class A {
public:
explicit A(int a)
:_a(a)
{
}
private:
int _a;
};

int main()
{
A a = 1;
return 0;
}

3、static成员

class A{
public:

void Print()
{
cout << _b << endl;
}

private:
static int _b;
};

//静态成员初始化
int A::_b = 1;

int main()
{
A a;
a.Print();
A b;
b.Print();

return 0;
}

class A {
public:

void Print()
{
cout << _b << endl;
}

//private:
static int _b;
};

int A::_b = 1;

int main()
{
A a;
//直接访问_b要设为公有
cout << A::_b << endl;
cout << a._b << endl;

return 0;
}

4、匿名对象

创建一个没有名字的对象称为匿名对象，它的生命周期只在它定义的那一行，那一行结束自动调用析构。

class A{
public:

A(int a)
:_a(a)
{
cout << "A(int a)" << endl;
}

void Print()
{
cout << _a << endl;
}

private:
int _a;
};

class Stack {
public:
//构造函数
Stack(int n = 4)
{
cout << "Stack(int n = 4)" << endl;
int* tmp = (int*)malloc(n * sizeof(int));
if (tmp == nullptr)
{
perror("malloc fail");
return;
}
array = tmp;
size = n;
capacity = 0;
}

//析构函数
~Stack()
{
cout << "~Stack()" << endl;
if (array != nullptr)
{
free(array);
array = nullptr;
capacity = size = 0;
}
}

private:
int* array;
int capacity;
int size;
};

int main()
{
Stack();
A(1).Print();

return 0;
}

5、友元

class A {
public:
//定义在公有
friend void Print(const A& a, const B& b);
A(int a)
:_a(a)
{}
private:
int _a = 0;
};

class B {
public:
B(int b)
:_b(b)
{
}
private:
//定义在私有
friend void Print(const A& a,const B& b);
int _b = 0;
};

void Print(const A& a, const B& b)
{
cout << a._a << endl;
cout << b._b << endl;
}

int main()
{
A a = 1;
B b = 2;
Get(a, b);
return 0;
}

6、内部类

class B {
public:
//构造函数
B(int a,int b)
:_a(a),_b(b)
{ }

//内部类
class A {
public:
//打印_b
void Print_b(const B& b)
{
cout << b._b << endl;
}

private:
int _a;
};

private:
int _a;
int _b;
};

int main()
{
B b = { 10,20 };

B::A a;

a.Print_b(b);

return 0;
}

7、对象拷贝时的编译器优化

class A {
public:
A(int a = 1)
:_a(a)
{
cout << "A(int a)" << endl;
}

A(const A& a)
{
cout << "A(const A& a)" << endl;
this->_a = a._a;
}

A& operator=(const A& a )
{
cout << "A& operator=(const A& a )" << endl;
this->_a = a._a;
return *this;
}

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

private:
int _a = 0;
};

void f1(A aa)
{
}

A f2()
{
A aa;
return aa;
}

int main()
{
// 传值传参
// 构造+拷贝构造
A aa1;
f1(aa1);
cout << endl;

// 隐式类型，连续构造+拷贝构造->优化为直接构造
f1(1);
cout << endl;

// ⼀个表达式中，连续构造+拷贝构造->优化为⼀个构造
f1(A(2));
cout << endl;

//…
return 0;
}