C++编程面向对象入门全面详解

C++编程面向对象入门全面详解攻略

本篇攻略旨在为初学者提供C++编程中面向对象的入门指南，以及相关基础概念的详细介绍。

面向对象编程的概念

面向对象编程是一种程序设计范型，它将现实世界中的事物抽象、封装为类，并通过类之间的继承、组合等关系，对这些事物进行描述和操作。

在C++中，面向对象编程主要包含以下几个方面：

• 类(Class)：描述某一类事物的数据和行为的封装；
• 对象(Object)：类的实例化，具有该类特征和行为的一个具体存在；
• 继承(Inheritance)：一个类可以从另一个类派生出来，并且继承父类的特征和行为；
• 多态(Polymorphism)：不同的对象可以以相同的方式进行操作，同时也可以以不同的方式处理相同的事情。

面向对象编程中的类

C++中，类可以看做是数据与函数的组合，即数据成员和成员函数。

数据成员

数据成员是类中用于表示数据的变量，可以是各种数据类型，例如int、float、double、char、string等。在类中，数据成员通常被声明为私有(private)或保护(protected)的成员，在类的外部无法访问，仅能通过成员函数进行操作。

私有成员使用关键字private声明，只能在类内部使用，无法在类外访问：

class Apple {
  private:
    int price;
};

保护成员使用关键字protected声明，继承类可以直接访问保护成员：

class Pear {
  protected:
    int price;
};

成员函数

成员函数是类中用于处理类的数据的函数，也称为方法。成员函数在类声明中进行定义，在使用过程中，需要先创建对象，然后使用对象访问成员函数。

成员函数可以分为两种类型：

• 常规成员函数：在类中声明和定义，看作是类的行为，可以访问对象的数据成员；
• 静态成员函数：被声明为static的成员函数，可以访问类的静态数据成员，并且不依赖于任何对象。

成员函数的定义如下：

class Fruit {
  public:
    void setPrice(int p) {          // 常规成员函数
      price = p;
    }
    static void printNumber() {     // 静态成员函数
      cout << "total numbers of fruits are " << numbers << endl;
    }
  private:
    int price;
    static int numbers;
};

在类外部，可以使用运算符::访问静态数据成员和静态成员函数：

int Fruit::numbers = 0;             // 静态成员变量的定义和初始化
Fruit apple, pear;

apple.setPrice(10);
pear.setPrice(8);
Fruit::printNumber();

面向对象编程中的继承

继承是面向对象编程中一个重要的特性，它允许一个类派生出另一个类，并且新类继承了旧类的属性和方法。

在C++中，继承可以分为三种类型：

• 公有继承(Public Inheritance)：新类中的公有成员和保护成员可以直接访问父类中的公有成员和保护成员，而不能访问父类中的私有成员；
• 私有继承(Private Inheritance)：新类中的所有成员都无法直接访问父类中的成员；
• 保护继承(Protected Inheritance)：新类中的所有成员都可以访问父类中的保护成员，但无法访问其公有成员和私有成员。

示例一：通过继承实现多态

class Shape {
public:
    virtual double area() = 0;     // 定义纯虚函数，由子类实现
};

class Rectangle : public Shape {   // 子类继承父类
public:
    Rectangle(double l, double w) {
        length = l;
        width = w;
    }
    double area() {                  // 实现父类中的纯虚函数
        return length * width;
    }
private:
    double length;
    double width;
};

class Circle : public Shape {      // 子类继承父类
public:
    Circle(double r) {
        radius = r;
    }
    double area() {                 // 实现父类中的纯虚函数
        return radius * radius * 3.1415926;
    }
private:
    double radius;
};

void printArea(Shape *shape) {     // 父类指针指向子类对象
    cout << "The area of the shape is " << shape->area() << endl;
}

int main() {
    Rectangle rec(5, 10);         // 子类对象
    Circle cir(5);                // 子类对象

    printArea(&rec);
    printArea(&cir);

    return 0;
}

示例二：多重继承实现

class Animal {
public:
    virtual void sound() = 0;
};

class Mammal : public Animal {
public:
    void sound() {
        cout << "This is the sound of a mammal." << endl;
    }
};

class Bird : public Animal {
public:
    void sound() {
        cout << "This is the sound of a bird." << endl;
    }
};

class Fish : public Animal {
public:
    void sound() {
        cout << "This is the sound of a fish." << endl;
    }
};

class Platypus : public Mammal, public Bird {
public:
    void sound() {
        Mammal::sound();
        Bird::sound();
    }
};

int main() {
    Platypus platypus;
    platypus.sound();

    return 0;
}

以上两个示例分别演示了通过继承实现多态和多重继承的过程，读者可在实践中进一步加深理解。