类和对象：C++11新特性与知识补充

DevKevin

于 2024-07-15 21:23:41 发布

阅读量898

点赞数 61

分类专栏： C++ 文章标签： c++ java jvm

本文链接：https://blog.csdn.net/SDFsoul/article/details/140449370

版权

C++ 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

Kevin的技术博客.png

（一）初始化列表

初始化列表格式

// 成员变量(值 / 表达式)
Date(int& x, int year = 1, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    ,_t(12)
    ,_ref(x)
    ,_n(1)
{
    // error C2512: “Time”: 没有合适的默认构造函数可⽤
    // error C2530 : “Date::_ref” : 必须初始化引⽤
    // error C2789 : “Date::_n” : 必须初始化常量限定类型的对象
}

private:
    int _year;
    int _month;
    int _day;
    Time _t; // 没有默认构造
    int& _ref; // 引⽤
    const int _n; // const

在创建一个对象的时候一定会通过初始化列表来对成员变量进行初始化，其中规则如下：

每个成员变量在初始化列表中只能出现⼀次；
成员变量在类内声明，在初始化列表定义；
引用成员变量（定义的时候必须指定引用对象），const成员变量（定义后的值再不可以改变），以及没有默认构造的类类型成员变量（无法自己构造），必须放在初始化列表进行初始化，否则会造成编译器报错；

成员变量声明位置缺省值（C++11）

缺省值的作用

初始化列表就是成员变量定义的地方，每个成员都要走初始化列表

没有显式在初始化列表进行定义的成员：
声明时有缺省值：会在经历初始化列表的时候用缺省值进行定义
声明时没有缺省值：
内置类型：看编译器，大概率随机值
自定义类型：调用默认构造，无默认构造时候会报错

private:
    // 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的
    // 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化
    int _year = 1;
    int _month = 1;
    int _day;
    Time _t = 1;
    const int _n = 1;
    int* _ptr = (int*)malloc(12);

缺省值与传递参数的关系

通过传递参数，如果在构造函数初始化列表显式初始化或者函数体内使用参数的话那参数值就没有发挥出作用；
因为每个成员都需要通过初始化列表进行初始化，如果在初始化列表没有显式初始化的话，成员就会通过声明处的缺省值进行初始化
所以说明缺省值是与初始化列表相对应的，与参数的传递无关

**缺省值确实是与初始化列表相对应的，并且只有在初始化列表没有显式初始化成员变量时，缺省值才会被使用。参数传递只是提供了一个在初始化列表中使用的值的方式。通过参数传递的值，如果在初始化列表中显式使用，则将覆盖声明处的缺省值。 **

（二）类型转换

类型转换是将一种类型的数据转换为另一种类型的过程。C++ 支持多种类型转换机制，包括隐式类型转换和显式类型转换。

隐式类型转换

隐式类型转换（Implicit Conversion），又称自动类型转换，是指编译器自动将一种数据类型转换为另一种数据类型的过程。

内置类型隐式转换成类类型

C++ 支持将内置类型隐式转换为类类型对象，为了支持隐式类型转换，类需要提供一个接受单个参数的构造函数。例如：

class A {
public:
    // 构造函数，支持隐式类型转换
    A(int a1) : _a1(a1) {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }

private:
    int _a1 = 1;
    int _a2 = 2;
};

int main() {
    A aa1 = 1; // 隐式类型转换：int -> A  调用构造函数
    aa1.Print();
    
    return 0;
}

多参数构造函数与 C++11

在 C++11 之前，隐式类型转换仅支持单参数构造函数。C++11 引入了使用花括号初始化的方式，可以支持多参数转换：

class A {
public:
    A(int a1, int a2) : _a1(a1), _a2(a2) {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }

private:
    int _a1 = 1;
    int _a2 = 2;
};

int main() {
    A aa3 = {2, 2}; // C++11 花括号初始化
    aa3.Print();
    
    return 0;
}

临时变量

当我们进行类型转换时，特别是在隐式类型转换的情况下，编译器有时会创建一个临时对象作为中间变量。这个中间变量用于在转换过程中存储临时结果，然后再将结果传递给目标对象。

编译器一般会对该过程进行优化，不会创建临时变量而是直接构造，但是也有必须创建临时变量的时候：

A aa1 = 1; // 隐式类型转换：int -> A
aa1.Print();

const A& aa2 = 1; // 隐式类型转换并生成临时对象
aa2.Print();

A aa3 = {2}; // 隐式类型转换：int -> A
aa3.Print();

const A& aa2 = 1;：这里也进行了隐式类型转换，但由于是引用绑定，首先调用了 A(int a1) 构造函数生成了一个临时对象，然后调用了拷贝构造函数将临时对象绑定到 aa2。

explicit 关键字

为了防止隐式类型转换，可以在构造函数前加上 explicit 关键字。例如：

class A {
public:
    // explicit 构造函数，禁止隐式类型转换
    explicit A(int a1) : _a1(a1) {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }

private:
    int _a1 = 1;
    int _a2 = 2;
};

int main() {
    // A aa1 = 1; // 错误：explicit 构造函数禁止隐式类型转换
    A aa1(1); // 正确：显式类型转换
    aa1.Print();
    
    return 0;
}

（三）`static`成员

用sratic修饰的成员变量，称为静态成员变量。

使用说明

static成员在类内声明，在类外定义；
静态成员变量为类内所有对象实例所共享，不属于声明static成员变量的类的其他类的实例不能访问这个变量；
静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针；
⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数；
静态成员也是类的成员，受public、protected、private访问限定符的限制；
静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员
变量不属于某个对象，不⾛构造函数初始化列表。

代码实例

class A
{
public :
	A()
	{
		++_scount;
	} 

	A(const A& t)
	{
		++_scount;
	} 
	
	~A()
	{
		--_scount;
	}

	static int GetACount()
	{
		return _scount;
	}

private:
	// 类⾥⾯声明
	static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;

static成员时私有的，所以可以使用共有的static成员函数作为接口来调用。

（四）友元

友元在 C++ 编程中提供了一种突破类的封装机制，允许非成员函数或其他类访问类的私有和保护成员。友元包括友元函数和友元类，友元函数和友元类可以访问类的私有和保护成员。

友元函数

定义与作用

友元函数是一种特殊的非成员函数，可以通过友元函数访问类的私有和保护成员
在类内使用friend关键字声明友元函数

特点

友元函数只是声明，所以可以在类的定义的任何地方声明，不受类的访问限定符的限制。
一个函数可以是多个类的友元函数。
友元函数仅仅是声明，不是类的成员函数。

代码示例：

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;
}

友元类

定义与作用

友元类是一个类的所有成员函数都可以访问另一个类的私有和保护成员。
在一个类内部用 friend class 声明另一个类为友元类。

特点

友元类的关系是单向的，不具有交换性。例如，A 类是 B 类的友元，但是 B 类不是 A 类的友元。
友元类的关系不能传递。如果 A 是 B 的友元，B 是 C 的友元，但是 A 不是 C 的友元。
友元类会增加耦合度，破坏封装，所以不宜多用。

（五）内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。

内部类是⼀个独⽴的类，只是受外部类类域限制和访问限定符限制，所以外部类在定义对象的时候，其中不包括内部类。
内部类默认是外部类的友元类，可以使用外部类的成员。
内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以考
虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其
他地⽅都⽤不了。

class A
{ 
private:
	static int _k;
	int _h = 1;

public:
	class B // B默认就是A的友元
	{ 
		public:
			void foo(const A& a)
			{
				cout << _k << endl; //OK
				cout << a._h << endl; //OK
			}
	};
};
int A::_k = 1;

int main()
{
	cout << sizeof(A) << endl;

	A::B b;

	A aa;
	b.foo(aa);

	return 0;
}