Python到C++: 函数与面向对象编程（OOP）

不止于python

发布于 2025-04-02 06:32:40

9700

代码可运行

文章被收录于专栏：不止于python不止于python

运行总次数：0

代码可运行

函数与返回值

在 C++ 中，函数是程序中的基本单位。每个函数都拥有返回类型、函数名和参数列表，函数执行后返回相应的结果。

1.1 C++ 函数定义与返回值

示例：

#include <iostream>
using namespace std;

// 定义一个简单的函数，返回两个数的和
int add(int a, int b) {
    return a + b;  // 返回两数之和
}

int main() {
    int result = add(10, 20);  // 调用 add 函数
    cout << "Sum: " << result << endl;
    return 0;
}

解析：

• 返回类型：int 表示该函数返回一个整数。
• 函数定义：add 函数接收两个整数参数，计算它们的和并返回结果。
• 函数调用：在 main() 函数中调用 add，并将结果存储到 result 变量中。

1.2 函数传参方式

C++ 支持三种传递参数的方式：按值传递、按引用传递和按指针传递。

1.2.1 按值传递（传递副本）

函数接收参数的副本，修改副本不会影响原始数据。

#include <iostream>
using namespace std;

void addValue(int x) {
    x += 10;  // 修改副本
}

int main() {
    int a = 5;
    addValue(a);  // 传递 a 的副本
    cout << "a = " << a << endl;  // a 不变，仍然是 5
    return 0;
}

1.2.2 按引用传递（传递地址）

通过引用传递参数，函数直接修改原始数据。

#include <iostream>
using namespace std;

void addReference(int& x) {
    x += 10;  // 修改原数据
}

int main() {
    int a = 5;
    addReference(a);  // 传递 a 的引用
    cout << "a = " << a << endl;  // a 被修改，结果为 15
    return 0;
}

1.2.3 按指针传递（通过指针传递地址）

使用指针传递参数，函数通过指针修改数据。

#include <iostream>
using namespace std;

void addPointer(int* x) {
    *x += 10;  // 通过指针修改数据
}

int main() {
    int a = 5;
    addPointer(&a);  // 传递 a 的地址
    cout << "a = " << a << endl;  // a 被修改，结果为 15
    return 0;
}

2. 面向对象编程（OOP）

C++ 是一种支持面向对象编程（OOP）的语言，它通过封装、继承和多态来提供强大的结构化设计能力。

2.1 类与构造函数

C++ 中的类与 Python 类似，类成员包含数据和方法。构造函数用于初始化对象。

C++ 类与构造函数示例：

#include <iostream>
using namespace std;

class Person {
public:
    string name;
    int age;

    // 构造函数
    Person(string n, int a) {
        name = n;
        age = a;
        cout << "Constructor called!" << endl;
    }

    void introduce() {
        cout << "My name is " << name << " and I am " << age << " years old." << endl;
    }

    ~Person() {  // 析构函数
        cout << "Destructor called!" << endl;
    }
};

int main() {
    // 创建对象时自动调用构造函数
    Person p1("John", 25);
    p1.introduce();  // 调用成员函数

    return 0;  // 程序结束时自动调用析构函数
}

// 输出
Constructor called!
My name is John and I am 25 years old.
Destructor called!

解析：

• 构造函数：Person(string n, int a) 初始化 name 和 age 成员。
• 析构函数：~Person() 是析构函数，当对象生命周期结束时自动调用，用于清理资源。
• 成员函数：introduce 输出对象的属性。

2.2 继承

继承是 OOP 的核心概念之一，它允许子类继承父类的成员函数和数据成员，从而实现代码复用。

C++ 继承示例：

#include <iostream>
using namespace std;

// 基类
class Animal {
public:
    void speak() {
        cout << "Animal speaks!" << endl;
    }
};

// 派生类
class Dog : public Animal {
public:
    void speak() {
        cout << "Dog barks!" << endl;
    }
};

int main() {
    Animal a;
    Dog d;

    a.speak();  // 调用基类的函数
    d.speak();  // 调用派生类的函数

    return 0;
}

// 输出
Animal speaks!
Dog barks!

解析：

• 基类 Animal：提供了 speak() 函数。
• 派生类 Dog：继承了 Animal 类并重写了 speak() 函数。
• 多态性：C++ 允许我们通过基类指针或引用调用派生类的方法，具体调用哪个版本的函数取决于对象的实际类型。

2.3 多态

多态是 C++ 中的一项强大特性，它允许同一个接口以不同的方式进行操作。

C++ 多态示例：

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() {  // 使用 virtual 关键字声明虚函数
        cout << "Animal speaks!" << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        cout << "Dog barks!" << endl;
    }
};

int main() {
    Animal * animalPtr;
    Dog dog;

    animalPtr = &dog;
    animalPtr->speak();  // 动态绑定，调用 Dog 类的 speak

    return 0;
}

// 输出
Dog barks!

解析：

• 虚函数：基类中的 speak() 被声明为 virtual，这使得 C++ 能够根据对象的实际类型决定调用哪个函数。
• 动态绑定：通过基类指针 animalPtr 指向 Dog 对象时，调用 speak() 会调用 Dog 类中的 speak() 函数。

注意

如果运行弹出警告如下:

tem.cpp:13:18: warning: 'override' keyword is a C++11 extension [-Wc++11-extensions]
   13 |     void speak() override {
      |                  ^
1 warning generated.