【C++指南】一文总结C++类和对象

???? 各位看官好，我是egoist2023！
???? 种一棵树最好是十年前，其次是现在！

???? 今天来学习C++类和对象的语法知识。注意：在本章节中，小编会以Date类举例

???? 如果觉得这篇文章有帮助，欢迎您一键三连，分享给更多人哦

类和对象的基本概念
- 类的定义
- 对象的创建
类的成员
- 数据成员
- 成员函数
访问控制
- 公有成员（public）
- 私有成员（private）
- 保护成员（protected）
构造函数和析构函数
- 构造函数
- 析构函数
拷贝构造函数和赋值运算符
- 拷贝构造函数
- 赋值运算符重载
静态成员
- 静态数据成员
- 静态成员函数
友元
- 友元函数
- 友元类
继承
- 基类和派生类
- 访问控制
- 多重继承
多态
- 虚函数
- 纯虚函数
- 抽象类
运算符重载
- 运算符重载的基本概念
- 常用运算符重载
模板类
- 类模板的定义
- 类模板的使用

1. 类和对象的基本概念

类的定义

类是C++中的核心概念，用于描述对象的属性和行为。类定义使用关键字class。

class MyClass {
public:
    // 公有成员
    int myVar;
    void myFunction() {
        // 函数实现
    }
private:
    // 私有成员
    int myPrivateVar;
};

对象的创建

对象是类的实例，通过类名创建。

MyClass obj;
obj.myVar = 10;
obj.myFunction();

2. 类的成员

数据成员

数据成员是类中的变量，用于存储对象的状态。

class MyClass {
public:
    int myVar;
};

成员函数

成员函数是类中的函数，用于定义对象的行为。

class MyClass {
public:
    void myFunction() {
        // 函数实现
    }
};

3. 访问控制

公有成员（public）

公有成员可以在类的外部访问。

class MyClass {
public:
    int myVar;
};

私有成员（private）

私有成员只能在类的内部访问。

class MyClass {
private:
    int myPrivateVar;
};

保护成员（protected）

保护成员可以在派生类中访问。

class MyClass {
protected:
    int myProtectedVar;
};

4. 构造函数和析构函数

构造函数

构造函数在创建对象时自动调用，用于初始化对象。

class MyClass {
public:
    MyClass() {
        // 构造函数实现
    }
};

析构函数

析构函数在对象销毁时自动调用，用于清理资源。

class MyClass {
public:
    ~MyClass() {
        // 析构函数实现
    }
};

5. 拷贝构造函数和赋值运算符

拷贝构造函数

拷贝构造函数用于通过已有对象初始化新对象。

class MyClass {
public:
    MyClass(const MyClass &obj) {
        // 拷贝构造函数实现
    }
};

赋值运算符重载

赋值运算符重载用于将一个对象的值赋给另一个对象。

class MyClass {
public:
    MyClass& operator=(const MyClass &obj) {
        // 赋值运算符重载实现
        return *this;
    }
};

6. 静态成员

静态数据成员

静态数据成员属于类，而不是类的某个对象。

class MyClass {
public:
    static int myStaticVar;
};

静态成员函数

静态成员函数只能访问静态成员。

class MyClass {
public:
    static void myStaticFunction() {
        // 静态成员函数实现
    }
};

7. 友元

友元函数

友元函数可以访问类的私有成员。

class MyClass {
private:
    int myPrivateVar;
    friend void myFriendFunction(MyClass &obj);
};

void myFriendFunction(MyClass &obj) {
    obj.myPrivateVar = 10;
}

友元类

友元类可以访问另一个类的私有成员。

class MyClass {
private:
    int myPrivateVar;
    friend class MyFriendClass;
};

class MyFriendClass {
public:
    void accessPrivate(MyClass &obj) {
        obj.myPrivateVar = 10;
    }
};

8. 继承

基类和派生类

派生类继承基类的成员。

class BaseClass {
public:
    int baseVar;
};

class DerivedClass : public BaseClass {
public:
    int derivedVar;
};

访问控制

派生类可以访问基类的公有和保护成员。

class BaseClass {
protected:
    int protectedVar;
};

class DerivedClass : public BaseClass {
public:
    void accessProtected() {
        protectedVar = 10;
    }
};

多重继承

一个类可以继承多个基类。

class BaseClass1 {
public:
    int baseVar1;
};

class BaseClass2 {
public:
    int baseVar2;
};

class DerivedClass : public BaseClass1, public BaseClass2 {
public:
    int derivedVar;
};

9. 多态

虚函数

虚函数允许派生类重写基类的函数。

class BaseClass {
public:
    virtual void myFunction() {
        // 基类函数实现
    }
};

class DerivedClass : public BaseClass {
public:
    void myFunction() override {
        // 派生类函数实现
    }
};

纯虚函数

纯虚函数使类成为抽象类，不能实例化。

class BaseClass {
public:
    virtual void myFunction() = 0;
};

class DerivedClass : public BaseClass {
public:
    void myFunction() override {
        // 派生类函数实现
    }
};

抽象类

抽象类至少包含一个纯虚函数。

class AbstractClass {
public:
    virtual void myFunction() = 0;
};

10. 运算符重载

运算符重载的基本概念

运算符重载允许自定义类的运算符行为。

class MyClass {
public:
    int myVar;
    MyClass operator+(const MyClass &obj) {
        MyClass temp;
        temp.myVar = this->myVar + obj.myVar;
        return temp;
    }
};

常用运算符重载

常见的运算符重载包括+, -, *, /, ==, !=等。

class MyClass {
public:
    int myVar;
    bool operator==(const MyClass &obj) {
        return this->myVar == obj.myVar;
    }
};

11. 模板类

类模板的定义

类模板允许定义通用的类。

template <typename T>
class MyTemplateClass {
public:
    T myVar;
};

类模板的使用

使用类模板时指定具体类型。

MyTemplateClass<int> obj;
obj.myVar = 10;

秒客网