C++深入刨析类与对象的使用

什么是类与对象

在 C++ 中，类是对一类事物的抽象描述。类是一个代码模板，它描述了包含在对象中的属性和方法。而对象是类的一个实例。

比如，我们可以定义一个实体类 Person 来描述人的属性和方法，然后我们可以用实例化出来的对象来表示不同的人。比如有人叫张三，有人叫李四，那么我们可以将张三和李四看作是 Person 类的两个对象，各自拥有自己不同的属性。

类的定义与使用

在 C++ 中，定义一个类需要使用 class 或 struct 关键字，如下所示：

class Person {
public:
    std::string name;
    int age;
    void show() {
        std::cout << "My name is " << name << ", and I am " << age << " years old." << std::endl;
    }
};

上述代码中定义了一个 Person 类，包含了 name 和 age 两个属性，以及一个 show() 方法。

下面是如何使用上述定义出来的 Person 类：

int main() {
    // 实例化一个 Person 对象
    Person person;
    // 对 person 的属性进行赋值
    person.name = "张三";
    person.age = 18;
    // 调用 person 的 show 方法
    person.show();
    return 0;
}

上述代码中，我们首先通过 Person person; 实例化了一个 Person 对象，然后通过 person.name = "张三" 和 person.age = 18 给这个对象的属性进行了赋值，最后调用了 person.show() 方法。

构造函数与析构函数

在 C++ 中，每一个类都有至少一个构造函数。构造函数是在对象创建时自动调用的函数，用于初始化类的属性。

构造函数的名称和类名相同，并且没有返回值。如果没有声明构造函数，编译器会自动创建一个默认构造函数。

下面的示例代码中，我们在类中声明了一个默认构造函数，用来初始化对象的属性。

class Person {
public:
    // 默认构造函数
    Person() {
        name = "";
        age = 0;
    }
    std::string name;
    int age;
    void show() {
        std::cout << "My name is " << name << ", and I am " << age << " years old." << std::endl;
    }
};

析构函数是在对象销毁时自动调用的函数，用于清理对象占用的资源。如果没有声明析构函数，则编译器会自动创建一个默认析构函数。

下面的示例代码中，我们在类中声明了一个默认析构函数，用来清理对象占用的资源。

class Person {
public:
    // 默认构造函数
    Person() {
        name = "";
        age = 0;
    }
    // 默认析构函数
    ~Person() {
        std::cout << "Person对象被销毁了" << std::endl;
    }
    std::string name;
    int age;
    void show() {
        std::cout << "My name is " << name << ", and I am " << age << " years old." << std::endl;
    }
};

继承与多态

在 C++ 中，我们可以通过继承来创建一个新的类，新的类将继承原有类的所有属性和方法，并且可以添加自己的属性和方法。

继承分为公有继承、私有继承和保护继承三种类型。默认情况下，C++ 使用公有继承。

下面的示例代码中，我们定义了一个 Student 类来继承 Person 类：

class Student : public Person {
public:
    std::string major;
    void show() {
        std::cout << "My name is " << name << ", and I am " << age << " years old. I major in " << major << "." << std::endl;
    }
};

上述代码中，我们使用了公有继承的方式，让 Student 类继承了 Person 类的属性和方法，并且添加了自己的 major 属性和 show() 方法。

多态是 C++ 中一种重要的特性，它使得一个对象可以在不同的情况下表现出不同的行为。在 C++ 中实现多态需要使用虚函数。虚函数是一个在基类中声明的函数，在派生类中可以重写该函数。

下面的示例代码中，我们在 Person 类中定义了一个虚函数 show()，然后在 Student 类中重写了该函数：

class Person {
public:
    // 默认构造函数
    Person() {
        name = "";
        age = 0;
    }
    // 默认析构函数
    ~Person() {
        std::cout << "Person对象被销毁了" << std::endl;
    }
    std::string name;
    int age;
    virtual void show() {
        std::cout << "My name is " << name << ", and I am " << age << " years old." << std::endl;
    }
};

class Student : public Person {
public:
    std::string major;
    void show() {
        std::cout << "My name is " << name << ", and I am " << age << " years old. I major in " << major << "." << std::endl;
    }
};

在上述代码中，我们在 Person 类中将 show() 函数声明为了虚函数，并做了一个默认实现。然后在 Student 类中重写了该函数。这样，在我们通过 Person 类型的指针或引用调用 show() 方法时，会调用到相应的实现。

总结

本文介绍了类与对象的概念，以及如何定义类、实例化对象和使用对象的属性和方法。同时还介绍了构造函数、析构函数、继承和多态等 C++ 中的重要特性。通过本文的学习，您应该对 C++ 中的类与对象有了更深的理解。

示例1:

class Shape {
public:
    virtual double getArea() {
        return 0;
    }
};

class Circle : public Shape {
public:
    Circle(double r) {
        this->r = r;
    }
    double getArea() {
        return 3.14 * r * r;
    }
private:
    double r;
};

int main() {
    Shape *s = new Circle(2);
    cout << s->getArea() << endl; // 输出 12.56
    return 0;
}

上述代码中，我们定义了一个 Shape 类和一个 Circle 类，Circle 类继承于 Shape。在 Circle 类中，我们实现了 getArea() 方法，用来计算圆的面积。然后我们通过 Shape *s = new Circle(2) 实现了多态，将 Circle 类型的对象赋值给了 Shape 类型的指针。最终调用 s->getArea() 方法时，会调用到 Circle 类型的实现。

示例2:

class Animal {
public:
    virtual void eat() {
        cout << "Animal eat" << endl;
    }
};

class Cat : public Animal {
public:
    void eat() {
        cout << "Cat eat" << endl;
    }
};

int main() {
    Animal *a1 = new Animal();
    Animal *a2 = new Cat();
    a1->eat(); // 输出 Animal eat
    a2->eat(); // 输出 Cat eat
    return 0;
}

上述代码中，我们定义了一个 Animal 类和一个 Cat 类，Cat 类继承于 Animal。在 Cat 类中，我们重写了 eat() 方法。然后我们通过 Animal *a2 = new Cat() 实现了多态，将 Cat 类型的对象赋值给了 Animal 类型的指针。最终调用 a2->eat() 方法时，会调用到 Cat 类型的实现。