【嵌入式编程】c++编程个人总结 -- 持续更新

Gatsby2023

已于 2024-09-20 11:15:38 修改

阅读量918

点赞数 27

文章标签： c++ 开发语言

于 2024-09-20 11:07:10 首次发布

本文链接：https://blog.csdn.net/Gatsby2023/article/details/141462246

版权

本篇文章用于记录工作中优化代码进行的c++学习复盘总结，可能没有具体的逻辑，仅用于个人记录

格式为：概念解释+对应举例

1. 关于C++继承的多态

1.1 什么是多态

允许你以统一的接口来处理不同类型的对象的能力，同一个操作可以应用于不同类型的对象，而具体执行哪个操作则取决于对象的实际类型

人话就是：同名函数，能够在多个场景使用

一般有两种多态：

静态多态：参数列表类型不一致即可
动态多态：通过基类的虚函数实现

1.2 多态的举例：

我们的基类函数中makesound是一个虚函数，在派生类中，我们override了基类的这个函数，之后就可以复用对应的这个函数。

#include <iostream>

class Animal {
public:
    virtual void make_sound() {
        std::cout << "The animal makes a sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void make_sound() override {
        std::cout << "The dog barks" << std::endl;
    }
};

class Cat : public Animal {
public:
    void make_sound() override {
        std::cout << "The cat meows" << std::endl;
    }
};

void play_sound(Animal& animal) {
    animal.make_sound();
}

int main() {
    Animal a;
    Dog d;
    Cat c;

    play_sound(a);
    play_sound(d);
    play_sound(c);

    return 0;
}
```

输出：

```
The animal makes a sound
The dog barks
The cat meows
```

但是如果，基类的makesound函数不是虚函数会发生什么事情呢？

那么在派生类中将会直接调用基类的函数，而不是子类中的重写版本。

#include <iostream>

class Animal {
public:
    void make_sound() {
        std::cout << "The animal makes a sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void make_sound() {
        std::cout << "The dog barks" << std::endl;
    }
};

class Cat : public Animal {
public:
    void make_sound() {
        std::cout << "The cat meows" << std::endl;
    }
};

void play_sound(Animal& animal) {
    animal.make_sound();
}

int main() {
    Animal a;
    Dog d;
    Cat c;

    play_sound(a);
    play_sound(d);
    play_sound(c);

    return 0;
}
```

输出：

```
The animal makes a sound
The animal makes a sound
The animal makes a sound
```

2. 关于C++对象中的权限分类

2.1 关于对象中public，protected，private的使用权限

public（公共）：使用 public 修饰符声明的成员可以在任何地方被访问，包括类的内部、派生类和外部的其他类或函数。这是最高级别的访问权限。

使用场景：当你希望类的成员可以在任何地方都能访问和使用时，可以使用 public 修饰符。

--------------------------------------------------------------------------------------------------------------------------

protected（受保护）：使用 protected 修饰符声明的成员可以在类的内部和派生类中被访问，但不能在外部的其他类或函数中直接访问。这是中等级别的访问权限。

使用场景：当你希望类的成员仅能在类的内部和派生类中被访问，以实现一定程度的封装和保护时，可以使用 protected 修饰符。

--------------------------------------------------------------------------------------------------------------------------

private（私有）：使用 private 修饰符声明的成员只能在类的内部被访问，不能在派生类或外部的其他类和函数中访问。这是最低级别的访问权限。

使用场景：当你希望类的成员仅能在类的内部使用，以实现最大程度的封装和保护时，可以使用 private 修饰符。

2.2 使用权限举例：

class Person {
public:
    // 公共成员函数
    void setName(const std::string& name) {
        this->name = name;
    }

    std::string getName() const {
        return name;
    }

    void setAge(int age) {
        this->age = age;
    }

    int getAge() const {
        return age;
    }

protected:
    // 受保护的成员函数
    void setIdNumber(const std::string& idNumber) {
        this->idNumber = idNumber;
    }

    std::string getIdNumber() const {
        return idNumber;
    }

private:
    // 私有数据成员
    std::string name;
    int age;
    std::string idNumber;
};

在这个例子中，我们将name和age的getter和setter方法设置为public，因为我们希望在类外部可以访问和修改这些属性。而身份证号idNumber的getter和setter方法则设置为protected，这意味着只有Person类以及从Person类派生的子类可以访问和修改这些属性。私有数据成员则只能在Person类内部被访问。

总结：对于类内的一些比较敏感的变量，我们都设为private防止被外部无意更改，但是为了保证交互性，我们会在public里面设置对应的函数来操作访问这些变量，来保证数据的安全。

3. 关于创建对象的问题：

1. `MyClass *obj = new MyClass();` 这个语句使用`new`关键字在堆（heap）上动态地分配内存来创建一个`MyClass`类型的对象。变量`obj`是一个指向`MyClass`类型对象的指针。使用`new`创建的对象需要在不再使用后显式地使用`delete`关键字来释放内存。

2. `MyClass obj;` 这个语句在栈（stack）上创建一个`MyClass`类型的对象。这种情况下，`obj`是一个对象实例，而不是指针。栈上的对象在其作用域（scope）结束时会自动释放内存。 总结一下，这两个语句之间的区别主要在于对象的内存分配位置（堆还是栈）以及内存管理方式（显式释放还是自动释放）。在C++中，选择合适的方式创建对象取决于程序的需求和设计。