C++面向对象编程知识点合集总结和解释

1、类成员属性和函数

C++使用类的常见方式是：在头文件中声明类，然后在cpp文件中实现该类。不过，有时为了方便：

1. 也可以在文件的同一个地方，同时声明类，和实现类。
2. 也可以在类声明处直接实现类函数。

如下是类MyClass的头文件代码：

#pragma once
class MyClass
{
public:
    float width;
    float height;
    void printArea();
};

下面是MyClass的函数实现文件代码：

#include "MyClass.h"
#include <iostream>

void MyClass::printArea() {
    std::cout << width * height << std::endl;
}

下面是使用类的两种方式：使用new和delete、或者直接创建对象：

#include "MyClass.h"
void testClassM() {
    MyClass *mp = new MyClass();
    mp->width = 3.1415f;
    mp->height = 16.07f;
    mp->printArea();
    delete mp;

    MyClass mc;
    mc.width = 14.95f;
    mc.height = 36.08f;
    mc.printArea();
}

2、C++类访问修饰符

C++的类有三个可用的访问修饰符：public、private、protected，访问修饰符是用来标记一个函数或一个变量在某个作用域中是否可用。区分访问修饰符主要有三个作用域：本类、子类或派生类以及其它地方（使用该类的地方如main函数中）：

1. 在本类中，如果不使用这三个修饰符，默认的修饰符是private（结构体的默认修饰符是public，这是类和结构体的主要不同），在类中可访问本类的所有成员，是否使用修饰符无影响。
2. 在子类中，设private、protected和public的优先级值为1、2、3，C++中的继承有private、protected和public三种继承。子类继承父类后，父类的成员在子类中：private继承最大变成private修饰，protected继承最大变成protected修饰，public继承最大变成public修饰（也就是不变）。

一般来说，我们常用的是public继承，也就是父类的成员修饰在子类中保持不变。如果需要给外部访问则使用public修饰，如果只给子类访问则使用protected，如果只给本类使用，则使用private。

下面是一个用法例子：

#pragma once

#include <iostream>

class AbstractBox
{
private:
    float p;
protected:
    float width;
    float height;

public:
    AbstractBox(float w, float h) : width(w), height(h), p(3.14f) {
    }

    void print() {
        std::cout << "AbstractBox: " << width * height << std::endl;
    }
};

class MyBox : public AbstractBox {
private:
    float length;

public:
    MyBox(float w, float h, float l) : AbstractBox(w, h), length(l) {

    }

    void print() {
        std::cout << "MyBox: " << width * height * length << std::endl;
    }
};

#include "AbstractBox.h"
void testBox() {
    AbstractBox ab(1.32f, 3.6f);
    ab.print();

    AbstractBox* b1 = new AbstractBox(2.3f, 4.4f);
    b1->print();

    b1 = new MyBox(2.3f, 4.4f, 3.04f);
    MyBox* b2 = new MyBox(2.3f, 4.4f, 3.04f);
    b1->print(); // AbstractBox
    b2->print(); // MyBox
    ((AbstractBox*)b2)->print(); // AbstractBox
}

3、构造函数和析构函数

构造函数在对象创建时调用，析构函数在释放对象时调用，析构函数的名称为在类名前面加了个波浪号（~）作为前缀。

构造函数的主要任务是执行成员或其它相关的初始化操作，析构函数的主要任务是释放成员或其它一些资源如数据库连接等。构造函数需要手动调用，而析构函数不需要手动调用。

下面是一个使用例子：

#pragma once

#include <iostream>

class Shape
{
public:
    Shape() {
        std::cout << "create Shape object" << std::endl;
    }

    ~Shape() {
        std::cout << "delete Shape object" << std::endl;
    }

    virtual void print() {
        std::cout << "print Shape object" << std::endl;
    }
};

class Square : public Shape {
public:
    Square() {
        std::cout << "create Square object" << std::endl;
    }

    ~Square() {
        std::cout << "delete Square object" << std::endl;
    }

    void print() {
        std::cout << "print Square object" << std::endl;
    }
};

#include "Shape.h"
void testShape() {
    {
        Shape s;
        s.print();
    }
    std::cout << std::endl;
    {
        Square *s = new Square();
        s->print(); // Square
        ((Shape*)s)->print(); // Square
        delete s; // delete Square -> delete Shape
    }
}

4、C++的继承

C++支持三种继承方式：private、public和protected继承，常用的是public继承，另外C++支持多继承，一个类可以同时继承多个父类。