c++学习笔记- 面向对象

ldzyw

已于 2025-01-14 15:18:18 修改

阅读量562

点赞数 21

文章标签：笔记

于 2025-01-14 15:14:37 首次发布

本文链接：https://blog.youkuaiyun.com/ldzyw/article/details/133070925

版权

1.c++ 多态的实现，子类有实现就调用子类的函数，没有就是父类的函数

在Qt中，多态的实现主要依赖于C++的虚函数机制。通过将父类中的函数声明为虚函数，子类可以重写这些函数。当通过父类指针或引用调用这些虚函数时，会根据实际对象的类型调用相应的函数。如果子类没有重写某个虚函数，那么会调用父类中的实现。

示例

假设我们有一个父类 Base 和一个子类 Derived，我们希望在子类中重写父类的某个函数，如果没有重写则调用父类的实现。

1. 定义父类

cpp

#include <iostream>

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

    virtual ~Base() {}  // 虚析构函数，确保多态删除
};

2. 定义子类

cpp

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

3. 使用多态

cpp

int main() {
    Base* base = new Base();
    Base* derived = new Derived();

    base->doSomething();  // 输出: Base::doSomething()
    derived->doSomething();  // 输出: Derived::doSomething()

    delete base;
    delete derived;

    return 0;
}

解释

虚函数：Base 类中的 doSomething 函数被声明为虚函数。这意味着当通过父类指针或引用调用该函数时，会根据实际对象的类型调用相应的函数。
重写：Derived 类重写了 doSomething 函数。因此，当通过 Derived 类型的对象调用 doSomething 时，会调用 Derived 类中的实现。
未重写：如果 Derived 类没有重写 doSomething 函数，那么调用 doSomething 时会使用 Base 类中的实现。

注意事项

虚析构函数：为了确保通过父类指针删除子类对象时能够正确调用子类的析构函数，父类的析构函数应该声明为虚函数。
override关键字：在子类中重写虚函数时，可以使用 override 关键字。这有助于编译器检查是否正确重写了父类的虚函数，如果父类中没有相应的虚函数，编译器会报错。

通过这种方式，Qt中的多态机制可以确保在运行时根据实际对象的类型调用相应的函数，从而实现灵活的继承和多态行为。

2.c++ 纯虚函数

在C++中，纯虚函数（Pure Virtual Function）是一种特殊的虚函数，它没有具体的实现，仅在基类中声明。纯虚函数的目的是要求派生类必须提供该函数的具体实现，否则派生类也将成为抽象类，不能实例化对象。

纯虚函数的声明

纯虚函数的声明形式如下：

cpp

virtual 返回类型 函数名(参数列表) = 0;

示例

假设我们有一个基类 Shape，它定义了一个纯虚函数 draw，要求所有派生类必须实现这个函数。

1. 定义基类

cpp

#include <iostream>

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() {}  // 虚析构函数，确保多态删除
};

2. 定义派生类

cpp

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }
};

3. 使用多态

cpp

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();

    shape1->draw();  // 输出: Drawing a Circle
    shape2->draw();  // 输出: Drawing a Square

    delete shape1;
    delete shape2;

    return 0;
}

解释

纯虚函数：Shape 类中的 draw 函数被声明为纯虚函数。这意味着 Shape 类本身不能实例化对象，但要求所有派生类必须提供 draw 函数的具体实现。
抽象类：包含纯虚函数的类称为抽象类。抽象类不能实例化对象，但可以定义指向派生类对象的指针或引用。
override关键字：在派生类中实现纯虚函数时，可以使用 override 关键字。这有助于编译器检查是否正确重写了基类的纯虚函数，如果基类中没有相应的纯虚函数，编译器会报错。

注意事项

虚析构函数：为了确保通过基类指针删除派生类对象时能够正确调用派生类的析构函数，基类的析构函数应该声明为虚函数。
纯虚函数的实现：虽然纯虚函数没有具体的实现，但可以在基类中提供一个默认实现，派生类可以选择性地重写它。例如：

cpp

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() {}  // 虚析构函数，确保多态删除

    // 提供默认实现
    virtual void defaultDraw() {
        std::cout << "Default drawing" << std::endl;
    }
};

抽象类的用途：抽象类通常用于定义接口或基类，提供一组必须被派生类实现的函数。这有助于实现多态和代码的复用。

通过使用纯虚函数，C++中的多态机制可以确保在运行时根据实际对象的类型调用相应的函数，从而实现灵活的继承和多态行为

3.c++ 抽象类

在C++中，抽象类（Abstract Class）是一个不能被实例化的类，它通常包含一个或多个纯虚函数。抽象类的主要目的是定义一个接口或一组接口，这些接口必须由派生类实现。抽象类提供了一种机制，确保所有派生类都实现某些特定的函数，从而保证了多态的实现。

定义抽象类

抽象类的定义通常包含一个或多个纯虚函数。纯虚函数的声明形式如下：

cpp

virtual 返回类型 函数名(参数列表) = 0;

示例

假设我们有一个抽象类 Shape，它定义了一个纯虚函数 draw，要求所有派生类必须实现这个函数。

1. 定义抽象类

cpp

#include <iostream>

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() {}  // 虚析构函数，确保多态删除
};

2. 定义派生类

cpp

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }
};

3. 使用多态

cpp

int main() {
    // Shape shape;  // 错误：不能实例化抽象类
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();

    shape1->draw();  // 输出: Drawing a Circle
    shape2->draw();  // 输出: Drawing a Square

    delete shape1;
    delete shape2;

    return 0;
}

解释

抽象类：Shape 类是一个抽象类，因为它包含一个纯虚函数 draw。这意味着 Shape 类本身不能实例化对象，但可以定义指向派生类对象的指针或引用。
纯虚函数：draw 函数被声明为纯虚函数。这意味着 Shape 类本身不提供 draw 函数的具体实现，但要求所有派生类必须提供 draw 函数的具体实现。
虚析构函数：为了确保通过基类指针删除派生类对象时能够正确调用派生类的析构函数，基类的析构函数应该声明为虚函数。
override关键字：在派生类中实现纯虚函数时，可以使用 override 关键字。这有助于编译器检查是否正确重写了基类的纯虚函数，如果基类中没有相应的纯虚函数，编译器会报错。

注意事项

虚析构函数：为了确保通过基类指针删除派生类对象时能够正确调用派生类的析构函数，基类的析构函数应该声明为虚函数。
纯虚函数的实现：虽然纯虚函数没有具体的实现，但可以在基类中提供一个默认实现，派生类可以选择性地重写它。例如：

cpp

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() {}  // 虚析构函数，确保多态删除

    // 提供默认实现
    virtual void defaultDraw() {
        std::cout << "Default drawing" << std::endl;
    }
};

抽象类的用途：抽象类通常用于定义接口或基类，提供一组必须被派生类实现的函数。这有助于实现多态和代码的复用。

总结

抽象类通过纯虚函数提供了一种机制，确保所有派生类都实现某些特定的函数，从而保证了多态的实现。通过使用抽象类，可以定义一个通用的接口，让不同的派生类实现具体的细节，从而实现灵活的继承和多态行为

4.c++ 多态的几个特性

在C++中，多态是一种重要的面向对象编程特性，它允许通过基类的指针或引用调用派生类的成员函数。多态的实现主要依赖于虚函数机制。以下是多态的几个主要特性：

1. 虚函数（Virtual Function）

虚函数是实现多态的基础。通过将基类中的成员函数声明为虚函数，派生类可以重写这些函数。当通过基类指针或引用调用虚函数时，会根据实际对象的类型调用相应的函数。

示例

cpp

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

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

int main() {
    Base* base = new Derived();
    base->display();  // 输出: Derived::display()
    delete base;
    return 0;
}

2. 纯虚函数（Pure Virtual Function）

纯虚函数是一种特殊的虚函数，它没有具体的实现，仅在基类中声明。纯虚函数的声明形式为 virtual 返回类型函数名(参数列表) = 0;。包含纯虚函数的类称为抽象类，不能实例化对象。

示例

cpp

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() {}  // 虚析构函数，确保多态删除
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();

    shape1->draw();  // 输出: Drawing a Circle
    shape2->draw();  // 输出: Drawing a Square

    delete shape1;
    delete shape2;

    return 0;
}

3. 虚析构函数（Virtual Destructor）

为了确保通过基类指针删除派生类对象时能够正确调用派生类的析构函数，基类的析构函数应该声明为虚函数。这确保了在删除对象时，所有派生类的析构函数都会被调用，从而避免资源泄漏。

示例

cpp

class Base {
public:
    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* base = new Derived();
    delete base;  // 输出: Derived destructor, Base destructor
    return 0;
}

4. 多态的实现机制

多态的实现依赖于动态绑定（Dynamic Binding）或晚期绑定（Late Binding）。在运行时，根据对象的实际类型调用相应的虚函数。这通常通过虚函数表（Virtual Table，简称vtable）来实现。每个类都有一个虚函数表，表中存储了该类所有虚函数的地址。通过基类指针或引用调用虚函数时，会查找虚函数表中的地址，从而调用正确的函数。

示例

cpp

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

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

int main() {
    Base* base = new Derived();
    base->f1();  // 输出: Derived::f1()
    base->f2();  // 输出: Base::f2()
    delete base;
    return 0;
}

5. 多态的限制

只能通过基类指针或引用调用虚函数：多态只能通过基类的指针或引用实现，不能通过对象直接调用。
虚函数必须在基类中声明：派生类中的函数重写必须基于基类中已声明的虚函数。
抽象类不能实例化：包含纯虚函数的类称为抽象类，不能实例化对象，但可以定义指向派生类对象的指针或引用。

总结

多态是面向对象编程中的一个重要特性，通过虚函数机制实现。它允许通过基类指针或引用调用派生类的成员函数，从而实现灵活的继承和多态行为。虚函数、纯虚函数、虚析构函数和动态绑定是多态实现的关键机制。理解这些特性有助于更好地设计和实现面向对象的程序。

5.在C++中，面向对象编程的几个特性

在C++中，面向对象编程（OOP）主要包含以下几个核心特性：封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）和抽象（Abstraction）。这些特性共同支持了面向对象编程的灵活性和可维护性。

1. 封装（Encapsulation）

封装是指将数据（属性）和操作数据的方法（行为）封装在一起，形成一个独立的对象。封装还涉及到隐藏对象的内部状态和实现细节，仅通过对象提供的接口进行交互。

示例

cpp

class Account {
private:
    double balance;  // 封装的数据

public:
    // 构造函数
    Account(double initialBalance) : balance(initialBalance) {}

    // 存款方法
    void deposit(double amount) {
        balance += amount;
    }

    // 取款方法
    bool withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }

    // 获取余额
    double getBalance() const {
        return balance;
    }
};

2. 继承（Inheritance）

继承是指一个类（派生类）可以继承另一个类（基类）的属性和方法。派生类可以扩展或修改基类的行为，从而实现代码的复用和层次化设计。

示例

cpp

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() {}  // 虚析构函数
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }
};

3. 多态（Polymorphism）

多态是指通过基类的指针或引用调用虚函数时，根据实际对象的类型调用相应的函数。多态的实现依赖于虚函数机制，允许派生类重写基类的虚函数。

示例

cpp

void drawShape(Shape* shape) {
    shape->draw();  // 根据实际对象的类型调用相应的 draw 方法
}

int main() {
    Circle circle;
    Square square;

    drawShape(&circle);  // 输出: Drawing a Circle
    drawShape(&square);  // 输出: Drawing a Square

    return 0;
}

4. 抽象（Abstraction）

抽象是指通过接口或抽象类隐藏复杂的实现细节，仅暴露必要的操作接口。抽象类通常包含一个或多个纯虚函数，派生类必须实现这些纯虚函数。

示例

cpp

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() {}  // 虚析构函数
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }
};