C++学习：类和对象（三）
一、深入讲解构造函数
1. 什么是构造函数？
构造函数（Constructor）是在创建对象时自动调用的特殊成员函数，用于初始化对象的成员变量。构造函数的名称与类名相同，没有返回类型
2. 构造函数的类型
（1）默认构造函数
没有参数或所有参数都有默认值的构造函数
class Person {
public:Person() {name = "Unknown";age = 0;}
private:std::string name;int age;
};（2）有参构造函数
接受参数，用于自定义初始化对象的构造函数
class Person {
public:Person(const std::string& name, int age) : name(name), age(age) {}
private:std::string name;int age;
};（3）拷贝构造函数
用于创建对象的副本
class Person {
public:Person(const Person& other) : name(other.name), age(other.age) {std::cout << "拷贝构造函数被调用" << std::endl;}
private:std::string name;int age;
};（4）移动构造函数（C++11 引入）
用于移动资源，避免不必要的拷贝
class Person {
public:Person(Person&& other) noexcept : name(std::move(other.name)), age(other.age) {std::cout << "移动构造函数被调用" << std::endl;}
private:std::string name;int age;
};3. 构造函数的初始化列表
使用初始化列表可以在构造函数中直接初始化成员，尤其是常量成员或引用类型的成员
class Person {
public:Person(const std::string& name, int age) : name(name), age(age) {}
private:const std::string name;int& age;
};4. 构造函数的调用顺序
- 基类构造函数先于派生类构造函数被调用
- 成员对象的构造函数按照它们在类中声明的顺序被调用
5. 代码示例
#include <iostream>
#include <string>class Address {
public:Address(const std::string& city) : city(city) {std::cout << "Address 构造" << std::endl;}
private:std::string city;
};class Person {
public:Person() : name("Unknown"), age(0), address("Unknown City") {std::cout << "Person 默认构造" << std::endl;}Person(const std::string& name, int age, const std::string& city): name(name), age(age), address(city) {std::cout << "Person 有参构造" << std::endl;}Person(const Person& other): name(other.name), age(other.age), address(other.address) {std::cout << "Person 拷贝构造" << std::endl;}private:std::string name;int age;Address address;
};int main() {Person p1;Person p2("Alice", 30, "New York");Person p3 = p2;return 0;
}二、深入理解封装
1. 什么是封装？
封装（Encapsulation）是将数据和操作数据的方法绑定在一起，保护对象的内部状态不被外部直接访问和修改。它是面向对象编程的基本特性之一
2. 访问控制符
public：公共成员，外部可以访问protected：受保护成员，派生类可以访问private：私有成员，只有类内部可以访问
3. 为什么需要封装？
- 提高代码的安全性，防止数据被非法访问和修改
- 隐藏内部实现细节，提供清晰的接口
- 便于维护和扩展代码
4. 通过方法访问私有成员
class BankAccount {
public:BankAccount(double balance) : balance(balance) {}void deposit(double amount) {if (amount > 0) {balance += amount;}}bool withdraw(double amount) {if (amount > 0 && balance >= amount) {balance -= amount;return true;}return false;}double getBalance() const {return balance;}private:double balance;
};5. 代码示例
#include <iostream>class Rectangle {
public:void setWidth(double w) {if (w > 0)width = w;}void setHeight(double h) {if (h > 0)height = h;}double getArea() const {return width * height;}private:double width;double height;
};int main() {Rectangle rect;rect.setWidth(10);rect.setHeight(5);std::cout << "面积：" << rect.getArea() << std::endl;return 0;
}三、static 成员
1. 什么是 static 成员？
在类中，用 static 关键字修饰的成员称为静态成员。它们属于类本身，而不是某个对象
2. 静态成员变量
- 所有对象共享同一份静态成员变量
- 必须在类外进行定义和初始化
class Counter {
public:Counter() {++count;}static int getCount() {return count;}private:static int count;
};int Counter::count = 0;3. 静态成员函数
- 只能访问静态成员变量和其他静态成员函数
- 可以在不创建对象的情况下调用
class Math {
public:static double pi() {return 3.14159;}
};4. 代码示例
#include <iostream>class Student {
public:Student(const std::string& name) : name(name) {++totalStudents;}~Student() {--totalStudents;}static int getTotalStudents() {return totalStudents;}private:std::string name;static int totalStudents;
};int Student::totalStudents = 0;int main() {std::cout << "当前学生人数：" << Student::getTotalStudents() << std::endl;Student s1("Alice");Student s2("Bob");std::cout << "当前学生人数：" << Student::getTotalStudents() << std::endl;{Student s3("Charlie");std::cout << "当前学生人数：" << Student::getTotalStudents() << std::endl;}std::cout << "当前学生人数：" << Student::getTotalStudents() << std::endl;return 0;
}四、友元（friend）
1. 什么是友元？
友元是被类授予访问其私有和保护成员权限的函数或类。使用 friend 关键字声明
2. 友元函数
- 可以是普通函数或者类的成员函数
- 在类内声明，在类外定义
class Box {
private:double width;public:friend void setWidth(Box& b, double w);
};void setWidth(Box& b, double w) {b.width = w;
}3. 友元类
- 一个类可以将另一个类声明为友元，从而该友元类的成员函数可以访问本类的私有和保护成员
class Engine;class Car {
private:int speed;friend class Engine;
};class Engine {
public:void setSpeed(Car& car, int s) {car.speed = s;}
};4. 友元的用途
- 当需要某个函数或类访问另一个类的私有成员时
- 应谨慎使用，避免破坏封装性
5. 代码示例
#include <iostream>class Secret {
private:std::string password;public:Secret(const std::string& pwd) : password(pwd) {}friend void reveal(const Secret& s);
};void reveal(const Secret& s) {std::cout << "秘密是：" << s.password << std::endl;
}int main() {Secret s("123456");reveal(s);return 0;
}五、内部类（嵌套类）
1. 什么是内部类？
在一个类的定义中定义另一个类，称为内部类或嵌套类
2. 内部类的特性
- 内部类可以访问外部类的私有和保护成员
- 外部类需要通过对象来访问内部类的成员
3. 什么时候使用内部类？
- 当某个类只为另一个类服务时
- 为了更好地组织代码，提升封装性
4. 代码示例
#include <iostream>class Outer {
private:int outerData;public:Outer(int data) : outerData(data) {}class Inner {public:void displayOuterData(const Outer& o) {std::cout << "外部类数据：" << o.outerData << std::endl;}};
};int main() {Outer o(100);Outer::Inner i;i.displayOuterData(o);return 0;
}六、匿名对象
1. 什么是匿名对象？
没有被命名的临时对象，通常在表达式中创建，使用完后立即销毁
2. 匿名对象的用途
- 作为函数的返回值或参数
- 进行临时运算
3. 代码示例
#include <iostream>class Number {
public:Number(int value) : value(value) {std::cout << "构造：" << value << std::endl;}~Number() {std::cout << "析构：" << value << std::endl;}int getValue() const {return value;}private:int value;
};Number createNumber(int x) {return Number(x);
}int main() {Number(10); // 创建匿名对象std::cout << "--------" << std::endl;Number n = createNumber(20);std::cout << "n 的值：" << n.getValue() << std::endl;return 0;
}七、拷贝对象时的一些编译器优化
1. 什么是拷贝消除？
编译器优化的一种，避免不必要的对象拷贝，提高性能
2. 返回值优化（RVO）
当函数返回对象时，直接在调用者的空间构造对象，避免临时对象的生成
class Data {
public:Data() {std::cout << "Data 构造" << std::endl;}Data(const Data&) {std::cout << "Data 拷贝构造" << std::endl;}~Data() {std::cout << "Data 析构" << std::endl;}
};Data getData() {Data d;return d;
}int main() {Data d = getData();return 0;
}3. 使用 std::move 和移动语义
- 在需要移动对象而非拷贝时，使用
std::move
#include <vector>
#include <string>int main() {std::vector<std::string> vec;std::string str = "Hello";vec.push_back(std::move(str)); // 移动 str，而不是拷贝return 0;
}4. 代码示例
#include <iostream>class Example {
public:Example() {std::cout << "构造函数" << std::endl;}Example(const Example&) {std::cout << "拷贝构造函数" << std::endl;}Example(Example&&) noexcept {std::cout << "移动构造函数" << std::endl;}~Example() {std::cout << "析构函数" << std::endl;}
};Example createExample() {Example e;return e;
}int main() {Example e = createExample();return 0;
}