C++ 类与对象高级特性详解

在上述代码中，_year 是引用类型，_constValue 是常量，都必须在初始化列表中进行初始化。

1.3 初始化列表的优势

1. 提升性能

使用初始化列表避免了构造函数体内赋值的额外开销，尤其对于包含大量成员变量的类，能够显著提升性能。

2. 必须使用的场合

某些成员（如引用和常量）只能在初始化列表中进行初始化，这是 C++ 语言规范的要求。

1.4 成员变量的缺省值

在 C++11 中，可以在类内为成员变量赋予缺省值，这样即使构造函数没有显式赋值，也会使用这些默认值：

class Person {
private:
    int _age = 18;       // 缺省值
    std::string _name = "Unnamed"; // 缺省值
};

这种方式简化了构造函数，提高了代码的灵活性。

1.5 初始化列表的顺序规则

(1). 成员变量初始化顺序

尽管初始化列表的书写顺序可以自由选择，但成员变量的初始化顺序是由它们在类中声明的顺序决定的。

示例：

class Example {
private:
    int _x;
    int _y;
public:
    Example(int x, int y) : _y(y), _x(x) {} // _x 仍会先于 _y 初始化
};

(2). 成员变量初始化的逻辑

在初始化列表中，成员变量的初始化遵循以下逻辑：如果成员变量在初始化列表中显式初始化，则按照提供的值进行初始化。如果成员变量未在初始化列表中显式初始化，则有两种情况：成员变量在类中声明时有缺省值：按照缺省值初始化。成员变量在类中声明时没有缺省值：对于内置类型成员，初始化为随机值，可能是默认值 0 等，具体行为依赖于编译器。对于自定义类型成员，如果没有默认构造函数且无法自动初始化，将导致编译错误。

此外，引用类型成员、const 成员以及没有默认构造函数的类类型成员，必须在初始化列表中进行显式初始化，无法在构造函数体内赋值。

建议始终保持初始化列表中的顺序与成员变量声明顺序一致，以避免潜在的未定义行为。

1.6 常见错误

(1). 忘记初始化引用或常量成员

引用类型和常量成员必须通过初始化列表进行初始化，否则编译器会报错。

(2). 初始化顺序不一致

初始化顺序与成员变量声明顺序不一致时，可能导致未定义行为，尤其在成员变量之间存在依赖关系时更需谨慎。

二、类型转换

2.1 C++ 中的类型转换概述

在 C++ 中，类型转换是一个非常强大的功能。它允许我们在不同类型之间进行转换。在类中，类型转换通常通过构造函数或者类型转换运算符来实现。C++ 支持隐式和显式类型转换，这在开发复杂系统时非常有用。

2.2 隐式类型转换

如果一个类有一个接受单个参数的构造函数，那么该类的对象可以通过传递该类型的参数进行隐式构造。例如，假设我们有一个类 A，它有一个接受 int 类型参数的构造函数。

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

int main() {
    A obj = 10;  // 隐式类型转换：int 被转换为 A
    obj.print(); // 输出 A: 10
}

在上面的代码中，整数 10 被隐式地转换为 A 类的对象，并调用了 A 的构造函数。这个过程称为隐式类型转换。然而，隐式类型转换可能会导致意外的行为，因此我们通常希望控制这种行为。

2.3 使用 explicit 关键字阻止隐式类型转换

为了避免隐式类型转换导致的错误，我们可以使用 explicit 关键字来标记构造函数，这样该构造函数将不再允许隐式转换。

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

int main() {
    // A obj = 10; // 编译错误，因为构造函数是 explicit 的
    A obj(10);  // 必须显式调用构造函数
    obj.print();
}

在这个例子中，explicit 关键字阻止了 int 到 A 的隐式转换，因此必须通过显式地调用构造函数来创建对象。

2.4 类型转换运算符

除了构造函数，C++ 还支持类型转换运算符，它允许我们将类类型的对象转换为其他类型。类型转换运算符的定义形式如下：

operator 类型() {
    // 转换逻辑
}

例如：

class A {
public:
    A(int a) : _a(a) {}
    // 定义 int 类型的转换运算符
    operator int() {
        return _a;
    }
private:
    int _a;
};

int main() {
    A obj(10);
    int num = obj;  // 隐式调用转换运算符，将 A 对象转换为 int
    cout << "num: " << num << endl; // 输出 num: 10
}

在上面的代码中，类 A 提供了一个将 A 对象转换为 int 的运算符，因此可以直接将 A 对象赋值给一个 int 类型的变量。

三、静态成员 (static)

3.1 静态成员变量

static 成员变量是属于类本身的，而不是类的某个对象。也就是说，所有类的对象都共享同一个 static 成员变量。静态成员变量在类的所有对象之间共享，并且必须在类外部进行初始化。

示例代码：

class Counter {
public:
    Counter() { ++_count; }
    ~Counter() { --_count; }
    static int getCount() { return _count; }
private:
    static int _count;  // 静态成员变量
};

int Counter::_count = 0;  // 必须在类外初始化

int main() {
    Counter c1, c2;
    cout << "Current count: " << Counter::getCount() << endl; // 输出 2
    return 0;
}

在这个例子中，_count 是一个静态成员变量，用来计数创建的对象数量。由于它是静态的，所有 Counter 对象共享同一个计数器。

3.2 静态成员函数

静态成员函数与普通成员函数的主要区别在于，它们不能访问非静态的成员变量或成员函数。因为静态成员函数没有 this 指针，不能与具体的对象绑定。

示例代码：

class Example {
public:
    static void staticFunc() {
        cout << "This is a static function." << endl;
    }
};

int main() {
    Example::staticFunc(); // 静态成员函数可以通过类名直接调用
    return 0;
}

在上面的例子中，静态成员函数 staticFunc 是通过类名直接调用的，而不需要通过对象。

四、友元（Friend）

4.1 什么是友元？

C++ 中的友元（friend）是一种特殊机制，它允许一个函数或类访问另一个类的私有成员。通常，类的私有成员只能通过公共接口（如公共成员函数）访问，但有时候我们希望让另一个类或函数直接访问这些私有数据。友元就是为此设计的。友元函数：允许某个外部函数访问类的私有和保护成员。友元类：允许另一个类访问当前类的私有和保护成员。

4.2 友元函数的使用

友元函数并不是类的成员函数，但它有权访问类的私有成员。友元函数在类内部通过 friend 关键字声明。

class Box {
    friend void showBox(const Box& b); // 友元函数声明
private:
    int _length = 10;
    int _width = 5;
};

void showBox(const Box& b) {
    std::cout << "Box length: " << b._length << ", width: " << b._width << std::endl;
}

int main() {
    Box b;
    showBox(b); // 输出：Box length: 10, width: 5
    return 0;
}

4.3 友元类的使用

友元类中的所有成员函数都可以访问另一个类的私有成员。友元类的关系是单向的，即 A 类是 B 类的友元，但 B 类并不能访问 A 类的私有成员。

class Engine;

class Car {
    friend class Engine; // Engine 是 Car 的友元类
private:
    int _horsePower = 300;
};

class Engine {
public:
    void showHorsePower(const Car& c) {
        std::cout << "Car's horsepower: " << c._horsePower << std::endl; // 访问 Car 的私有成员
    }
};

int main() {
    Car myCar;
    Engine myEngine;
    myEngine.showHorsePower(myCar); // 输出：Car's horsepower: 300
    return 0;
}

4.4 友元的优缺点

友元提供了一种方便的方式来访问类的私有数据，增加了类之间的合作性。**然而，它也会破坏类的封装性和数据安全性。**因此，使用友元时要慎重，不宜过度使用。

五、内部类

**内部类是定义在另一个类中的类。**它通常用于封装两者之间的紧密关系，外部类可以控制内部类的行为。内部类在外部类中定义时，默认情况下可以访问外部类的私有成员。

示例代码：

class Outer {
private:
    int _data = 42;
public:
    class Inner {
    public:
        void show(const Outer& o) {
            cout << "Outer::_data = " << o._data << endl; // 访问外部类的私有成员
        }
    };
};

int main() {
    Outer outer;
    Outer::Inner inner;
    inner.show(outer); // 输出 Outer::_data = 42
    return 0;
}

在这个例子中，Inner 类是 Outer 类的内部类，它可以访问 Outer 类的私有成员 _data。

六、匿名对象

匿名对象是没有名字的临时对象，它们的生命周期非常短暂，只在当前语句中存在。匿名对象经常用于简化临时操作，不需要为它们显式命名。

示例代码：

class A {
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
};

int main() {
    A(); // 创建匿名对象
    return 0; // 匿名对象在这一行结束时自动销毁
}

在上面的代码中，匿名对象在创建后立即被销毁。匿名对象的使用使代码更简洁，但需要注意它们的生命周期。

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

在 C++ 中，编译器会进行一些优化，减少对象拷贝次数，从而提高性能。这些优化包括返回值优化（RVO）和拷贝省略。当一个函数返回一个对象时，编译器会尝试直接构造返回值，而不是先构造临时对象再拷贝。

示例代码：

class A {
public:
    A() { cout << "A()" << endl; }
    A(const A&) { cout << "A(const A&)" << endl; }
    ~A() { cout << "~A()" << endl; }
};

A createObject() {
    A obj;
    return obj; // 返回时优化
}

int main() {
    A a = createObject(); // 返回值优化
    return 0;
}

在这个例子中，编译器会进行优化，避免多次调用拷贝构造函数。

总结

本篇详细介绍了 C++ 类与对象的高级特性，包括构造函数的初始化列表、类型转换、静态成员、友元、内部类、匿名对象以及对象拷贝时的编译器优化。这些特性不仅增强了代码的灵活性，也帮助开发者编写出更加高效的程序。理解这些内容将大大提升你对 C++ 面向对象编程的理解能力，同时为编写健壮的应用程序奠定基础。