【C++】面向对象-CSDN博客

本文链接：https://blog.csdn.net/Bl_a_ck/article/details/147740424

C++ 面向对象编程（OOP）语法简介

面向对象编程（OOP）是 C++ 的核心特性之一。OOP 通过将数据和操作数据的方法封装在对象中，提供了更清晰、更模块化的代码结构。C++ 的 OOP 主要包括以下概念：类（Class）、对象（Object）、封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）。

1. 类和对象

类（Class）

类是用户定义的数据类型，用于封装数据（成员变量）和操作数据的方法（成员函数）。

cpp

复制

class Person {
public:  // 访问修饰符，表示公共成员
    std::string name;  // 成员变量
    int age;

    void introduce() {  // 成员函数
        std::cout << "My name is " << name << ", I am " << age << " years old." << std::endl;
    }
};

对象（Object）

对象是类的实例。通过对象可以访问类的成员变量和成员函数。

cpp

复制

Person person;  // 创建对象
person.name = "Alice";  // 访问成员变量
person.age = 25;
person.introduce();  // 调用成员函数

2. 访问修饰符

C++ 提供了三种访问修饰符，用于控制类成员的访问权限：

public：公共成员，可以在类外部访问。
private：私有成员，只能在类内部访问（默认）。
protected：受保护成员，只能在类内部和派生类中访问。

cpp

复制

class Person {
private:
    std::string secret;  // 私有成员

public:
    std::string name;
    int age;

    void setSecret(const std::string& s) {
        secret = s;  // 可以在类内部访问私有成员
    }

    void revealSecret() {
        std::cout << "Secret: " << secret << std::endl;
    }
};

3. 构造函数和析构函数

构造函数

构造函数在创建对象时自动调用，用于初始化对象。

cpp

复制

class Person {
public:
    std::string name;
    int age;

    // 构造函数
    Person(const std::string& n, int a) : name(n), age(a) {
        std::cout << "Person created: " << name << std::endl;
    }
};

析构函数

析构函数在对象销毁时自动调用，用于释放资源。

cpp

复制

class Person {
public:
    ~Person() {  // 析构函数
        std::cout << "Person destroyed: " << name << std::endl;
    }
};

4. 继承

继承允许一个类（派生类）从另一个类（基类）继承成员变量和成员函数。

cpp

复制

class Animal {
public:
    void eat() {
        std::cout << "Eating..." << std::endl;
    }
};

class Dog : public Animal {  // Dog 继承自 Animal
public:
    void bark() {
        std::cout << "Barking..." << std::endl;
    }
};

访问基类成员

派生类可以访问基类的公共成员和受保护成员。

cpp

复制

Dog dog;
dog.eat();  // 调用基类方法
dog.bark();  // 调用派生类方法

5. 多态

多态允许通过基类指针或引用调用派生类的重写函数。

虚函数

使用 virtual 关键字声明虚函数，派生类可以重写这些函数。

cpp

复制

class Animal {
public:
    virtual void speak() {  // 虚函数
        std::cout << "Animal speaks" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {  // 重写虚函数
        std::cout << "Dog barks" << std::endl;
    }
};

使用多态

通过基类指针或引用调用派生类的重写函数。

cpp

复制

Animal* animal = new Dog();
animal->speak();  // 输出 "Dog barks"
delete animal;

6. 抽象类和纯虚函数

抽象类是不能实例化的类，通常用于定义接口。纯虚函数是没有实现的虚函数。

cpp

复制

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

class Circle : public Shape {
public:
    void draw() override {  // 实现纯虚函数
        std::cout << "Drawing a circle" << std::endl;
    }
};

7. 友元函数和友元类

友元函数和友元类可以访问类的私有成员。

友元函数

cpp

复制

class Person {
private:
    std::string secret;

    friend void revealSecret(const Person& p);  // 声明友元函数
};

void revealSecret(const Person& p) {
    std::cout << "Secret: " << p.secret << std::endl;  // 访问私有成员
}

友元类

cpp

复制

class FriendClass {
public:
    void accessSecret(const Person& p) {
        std::cout << "Secret: " << p.secret << std::endl;  // 访问私有成员
    }
};

8. 运算符重载

C++ 允许重载运算符，使类对象支持自定义操作。

cpp

复制

class Vector {
public:
    int x, y;

    Vector operator+(const Vector& other) {  // 重载 + 运算符
        return {x + other.x, y + other.y};
    }
};

Vector v1 = {1, 2};
Vector v2 = {3, 4};
Vector v3 = v1 + v2;  // 使用重载的 + 运算符

9. 静态成员

静态成员属于类而不是对象，所有对象共享同一个静态成员。

cpp

复制

class Counter {
public:
    static int count;  // 静态成员变量

    Counter() {
        count++;  // 每次创建对象时增加计数
    }

    static void printCount() {  // 静态成员函数
        std::cout << "Count: " << count << std::endl;
    }
};

int Counter::count = 0;  // 初始化静态成员变量

Counter c1, c2;
Counter::printCount();  // 输出 "Count: 2"

10. 模板类

模板类允许编写通用的类，支持多种数据类型。

cpp

复制

template <typename T>
class Box {
public:
    T value;

    Box(T v) : value(v) {}

    void print() {
        std::cout << "Value: " << value << std::endl;
    }
};

Box<int> intBox(42);
Box<std::string> stringBox("Hello");
intBox.print();  // 输出 "Value: 42"
stringBox.print();  // 输出 "Value: Hello"