当前位置： 首页 > article >正文

【C++篇】深度解析类与对象（下）

article 2024/10/27 0:05:38

引言

在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。

无论你是C++的初学者还是有一定基础的开发者，本文都将为你提供详细的解释和实用的示例代码，帮助你掌握C++中的类与对象的高级用法。

一、再谈构造函数

构造函数是 C++ 中用于初始化对象的特殊函数。每次创建类的实例时，构造函数都会自动调用，用来为对象的成员变量赋初值。本篇将深入探讨构造函数的一些高级用法与技巧。

1.1 构造函数的初始化方式

在 C++ 中，构造函数可以通过两种方式为类的成员变量赋值：构造函数体内赋值和初始化列表。

(1). 构造函数体内赋值

传统方式是通过构造函数体来对成员变量赋值：

class Person {
public:
    Person(int age) {
        _age = age;  // 在构造函数体内赋值
    }
private:
    int _age;
};

这种方式虽然常见，但可能带来效率问题，因为成员变量会经历两次赋值——默认初始化后再赋值。

(2).初始化列表

初始化列表可以更高效地为成员变量赋值。其语法是在构造函数的参数列表后面使用冒号 :，直接对成员变量进行初始化：

class Person {
public:
    Person(int age) : _age(age) {}  // 使用初始化列表
private:
    int _age;
};

使用初始化列表可以避免默认初始化后的重复赋值，因而效率更高。

1.2 必须使用初始化列表的场景

在某些情况下，初始化列表是唯一可行的选择：

1.引用成员变量

引用类型必须在初始化时绑定对象，因此需要通过初始化列表来进行初始化，不能在构造函数体内赋值。

2.常量成员变量

常量成员变量一旦被赋值便不能修改，必须在初始化列表中赋值，不能在构造函数体内赋值。

3.没有默认构造函数的类类型成员

如果成员是其他类的对象且没有默认构造函数，则必须通过初始化列表进行初始化。否则，编译器无法为其分配默认初值，导致编译错误。

示例：

class Date {
public:
    Date(int& year, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day), _constValue(100) {}

private:
    int& _year;            // 引用类型成员变量
    const int _constValue; // 常量成员变量
    int _month;
    int _day;
};

在上述代码中，_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++面向对象编程的理解能力，同时为编写健壮的应用程序奠定基础。

希望本文的详细讲解对你有帮助！如果有任何疑问或需要进一步的解释，欢迎在评论区留言讨论。


http://www.kler.cn/news/366523.html

相关文章：

  • 改变组件默认上报事件的参数，添加额外参数
  • LeetCode_231. 2 的幂_java
  • 传奇996_5——使用补丁制作武器
  • 【论文阅读】ESRGAN+
  • Android 15自定义设置导航栏与状态栏，EdgeToEdge适配
  • 人工智能：未来生活与工作的变革者
  • Java爬虫：API数据界的“宝藏猎人”
  • Linux Java 多版本管理
  • 2024 年让这4个在线翻译器成为你语言沟通的得力助手。
  • 如何确保WordPress网站数据安全：定期备份与恢复
  • untiy中使用StackExchange.Redis读取Redis
  • python爬虫百度图片
  • 第五届无线大数据研讨会 日程表
  • 3. IoC 与DI
  • python如何读取Excel文件！
  • 使用virtualenv/Anaconda/Miniconda创建python虚拟环境
  • 实战分享：Golang中实现高性能日志记录与错误跟踪的艺术
  • Linux：sort与uniq
  • JavaScript 第23章：WebSocket 与实时通讯
  • sql获取时间差
  • ssh连接报错
  • 【Java设计模式】1-15章
  • 【Linux 从基础到进阶】性能测试工具使用（sysbench、fio等）
  • Linux 部署 mysql
  • vue3可组合函数和hook的用法和使用场景区别
  • 使用React构建现代Web应用