C++类和对象

C++类和对象

类和对象

1. 类和对象的基本概念

• 类 (Class): 类是C++中的一种用户定义的数据类型，它封装了数据和操作这些数据的函数。类定义了对象的属性和行为。
• 对象 (Object): 对象是类的实例。创建对象时，类的构造函数被调用来初始化对象的属性。

注意事项:

• 类的定义通常放在头文件 (.h 或 .hpp) 中，类的实现放在源文件 (.cpp) 中。
• 类名通常使用大写开头的驼峰命名法，如 MyClass。

2. 类的定义和成员

• 成员变量 (Member Variables): 又称数据成员，是类中定义的数据。
• 成员函数 (Member Functions): 又称方法，是类中定义的函数，用于操作成员变量。

class MyClass {
public:
    int myVariable;       // 成员变量
    void myFunction();    // 成员函数
};

注意事项:

• 成员变量应尽量使用私有访问修饰符 (private)，通过公有成员函数 (public) 进行访问，以实现封装。

3. 构造函数和析构函数

• 构造函数 (Constructor): 用于初始化对象，当对象创建时自动调用。构造函数没有返回类型，其名称与类名相同。
• 析构函数 (Destructor): 用于清理对象，当对象销毁时自动调用。析构函数也没有返回类型，其名称与类名前加波浪号 (~) 相同。

class MyClass {
public:
    MyClass() { /* 构造函数 */ }
    ~MyClass() { /* 析构函数 */ }
};

注意事项:

• 如果没有定义构造函数，C++编译器会生成一个默认构造函数。
• 析构函数不能被重载，一个类只能有一个析构函数。

4. 访问控制和封装

• 访问修饰符 (Access Specifiers): 用于控制类成员的访问权限，包括 public, private, 和 protected。
  • public: 公有成员可以被任何代码访问。
  • private: 私有成员只能被类的成员函数访问。
  • protected: 保护成员可以被类和其派生类的成员函数访问。

class MyClass {
private:
    int privateVar;
public:
    int publicVar;
protected:
    int protectedVar;
};

注意事项:

• 在实际开发中，建议成员变量尽量使用 private，通过公有成员函数提供访问接口，以实现封装和信息隐藏。

5. this指针

• this指针: 每个对象内部都有一个 this 指针，指向调用成员函数的对象本身。在成员函数中可以使用 this 指针访问对象的成员变量和成员函数。

class MyClass {
public:
    void setVar(int var) {
        this->myVariable = var;
    }
private:
    int myVariable;
};

注意事项:

• this 指针只能在类的成员函数中使用，不能在静态成员函数中使用。

6. 静态成员

• 静态成员变量 (Static Member Variables): 属于类而不是某个具体对象的变量。它们在所有对象之间共享。
• 静态成员函数 (Static Member Functions): 不依赖于某个对象的成员函数，可以直接通过类名调用。

class MyClass {
public:
    static int staticVar;
    static void staticFunction() {
        // 静态成员函数只能访问静态成员变量
        staticVar = 10;
    }
};

int MyClass::staticVar = 0; // 静态成员变量的定义

注意事项:

• 静态成员变量需要在类外定义和初始化。
• 静态成员函数不能访问非静态成员变量和成员函数。

7. 常量成员函数和常量对象

• 常量成员函数 (Const Member Functions): 不修改对象状态的成员函数。用 const 关键字修饰。
• 常量对象 (Const Objects): 不可修改的对象，用 const 关键字修饰。

class MyClass {
public:
    void myFunction() const {
        // 不能修改成员变量
    }
};

const MyClass obj;
obj.myFunction(); // 常量对象只能调用常量成员函数

注意事项:

• 常量成员函数只能调用其他常量成员函数。
• 常量对象只能调用常量成员函数。

8. 友元函数和友元类

• 友元函数 (Friend Functions): 可以访问类的私有和保护成员的非成员函数，用 friend 关键字声明。
• 友元类 (Friend Classes): 允许访问另一个类的私有和保护成员的类，用 friend 关键字声明。

class MyClass {
private:
    int privateVar;
public:
    friend void friendFunction(MyClass& obj);
};

void friendFunction(MyClass& obj) {
    obj.privateVar = 10; // 友元函数可以访问私有成员
}

注意事项:

• 使用友元函数和友元类时要谨慎，避免破坏类的封装性。

9. 运算符重载

• 运算符重载 (Operator Overloading): 允许为用户定义的类重载运算符，使其能够对对象进行操作。

class MyClass {
public:
    int var;
    MyClass operator+(const MyClass& other) {
        MyClass result;
        result.var = this->var + other.var;
        return result;
    }
};

注意事项:

• 并非所有运算符都可以重载。
• 重载运算符应保持运算符的原有语义，避免滥用。

10. 继承和多态

• 继承 (Inheritance): 允许一个类继承另一个类的属性和行为，形成父类 (Base Class) 和子类 (Derived Class) 的关系。
• 多态 (Polymorphism): 允许使用基类指针或引用调用子类的重载函数。通过虚函数 (Virtual Functions) 实现。

class Base {
public:
    virtual void show() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class" << std::endl;
    }
};

注意事项:

• 构造函数不能是虚函数。
• 使用多态时，确保基类的析构函数是虚函数。

11. 抽象类和纯虚函数

• 抽象类 (Abstract Class): 包含一个或多个纯虚函数的类，不能创建对象。
• 纯虚函数 (Pure Virtual Functions): 没有实现的虚函数，用 = 0 语法声明。

class AbstractClass {
public:
    virtual void pureVirtualFunction() = 0; // 纯虚函数
};

注意事项:

• 子类必须实现所有纯虚函数才能实例化对象。

12. 组合与聚合

• 组合 (Composition): 一个类包含另一个类的对象，形成“拥有”关系。
• 聚合 (Aggregation): 一个类包含另一个类的指针或引用，形成“部分-整体”关系。

class Engine {};

class Car {
private:
    Engine engine; // 组合关系
};

class Person {
private:
    Car* car; // 聚合关系
};

注意事项:

• 组合关系中，包含对象的生命周期由包含类管理。
• 聚合关系中，包含对象的生命周期不受包含类影响。

13. 深拷贝和浅拷贝

• 浅拷贝 (Shallow Copy): 复制对象时，只复制对象的内存地址，原对象和副本共享同一块内存。
• 深拷贝 (Deep Copy): 复制对象时，创建原对象的完整副本，两者独立。

class MyClass {
public:
    MyClass(const MyClass& other) {
        // 实现深拷贝
    }
};

注意事项:

• 如果类包含指针成员，确保实现深拷贝以避免潜在的内存泄漏或悬挂指针。

14. 智能指针

• 智能指针 (Smart Pointers): 提供自动内存管理的指针，包括 std::unique_ptr, std::shared_ptr, 和 std::weak_ptr。

#include <memory>

std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();

注意事项:

• 使用智能指针可以避免内存泄漏和悬挂指针问题，但需要理解其生命周期和使用场景。

通过以上各个

知识点的整理和讲解，你可以对C++中的类和对象有一个全面的了解。每个知识点都有其重要性和应用场景，掌握这些知识将有助于编写更高效、健壮的C++代码。