封装、继承、多态、重载:C++中的强大特性与代码设计

2024-01-02 20:00:09

封装

C++中的封装是一种面向对象编程的概念,它将数据(成员变量)和操作(成员函数)封装在一个类中,通过访问控制来限制对类内部实现的访问。封装提供了类与外部世界之间的接口,隐藏了类的内部实现细节,提高了代码的可维护性和安全性。

在C++中,封装可以通过使用访问修饰符(public、private、protected)来实现:

public(公有)访问修饰符允许类的成员在类的外部被访问,也可以在类的内部被访问。通常将公有成员函数作为类的接口,供外部使用。
private(私有)访问修饰符将类的成员隐藏在类的内部,外部无法直接访问私有成员变量和私有成员函数。通常将私有成员用于实现类的内部逻辑。
protected(保护)访问修饰符与私有访问修饰符类似,但允许派生类(子类)访问基类中的保护成员。
下面是一个简单的封装示例:

class MyClass {
private:
    int privateData;  // 私有成员变量

public:
    void setPrivateData(int data) {  // 公有成员函数
        privateData = data;
    }

    int getPrivateData() const {  // 公有成员函数
        return privateData;
    }
};

int main() {
    MyClass obj;
    obj.setPrivateData(42);
    int data = obj.getPrivateData();
    return 0;
}

在上面的示例中,私有成员变量privateData被封装在类MyClass中,外部无法直接访问。通过公有成员函数setPrivateData和getPrivateData来操作私有成员变量。

封装可以提供更好的代码组织和管理方式,同时也增强了代码的安全性,因为外部代码无法直接修改和访问类的内部数据。

C语言封装风格

当单一变量无法完成描述需求的时候,结构体类型解决了这问题。可以将多个类型打包成一体,形成新的类型,这是c语言中封装的概念。但是,新类型并不包含对数据类的操作,所有操作都是通过函数的方式,去进行封装。

1 #include<iostream>
  2 #include<string>
  3 using namespace std;
  4 
  5 struct person
  6 {
  7     string name;
  8     int age;
  9     int height;
 10 };
 11 void init(person* p)
 12 {
 13     p->name = "jiejie";
 14     p->age = 20;
 15     p->height = 130;
 16 }
 17 void show(person p)
 18 {
 19     cout<<"p.name = "<<p.name<<endl;
 20     cout<<"p.age = "<<p.age<<endl;
 21     cout<<"p.height = "<<p.height<<endl;
 22 }
 23 int main()
 24 {
 25     person per;
 26     init(&per);
 27     show(per);
 28 
 29     return 0;
 30 }
           

把数据放到一起用struct包装,然后把数据以引用或指针的方式传给行为。

C++封装

C++的封装认为C语言的封装不彻底,对于数据和行为分类,没有权限控制。
C++则提供控制选择,将数据和行为放在一起,对内开放数据,逻辑抽象。对外提供接口

  1 #include<iostream>
  2 using namespace std;
  3 
  4 class person
  5 {   
  6     public: 
  7         int num;
  8         void init()
  9         {
 10             cin>>this->num;
 11             cin>>this->age;
 12             cin>>this->height;
 13         }
 14         void show()
 15         {
 16             cout<<num<<endl;
 17             cout<<age<<endl;
 18             cout<<height<<endl;
 19         }
 20     
 21     protected:
 22         int age;
 23     private:
 24         int height;
 25 };
 26 int main()
 27 {
 28     person p;
 29     p.init();
 30     p.show();
 31     return 0;
 32 }
  

基本流程:
通过创建一个类,再通过创建类对象 再由对象调用行为,完成需求。

继承

C++中的继承是面向对象编程的一个重要概念,它允许一个类(派生类/子类)从另一个类(基类/父类)继承属性和行为。继承可以通过创建一个新类并从基类派生来实现,新类将自动获得基类的成员变量和成员函数,同时可以添加新的成员或重写基类的成员函数。

继承的主要目的是实现代码的重用和构建类之间的层次关系。在继承关系中,基类被称为超类或父类,派生类被称为子类。
一般定义格式如下:

class 派生类名标识符: [继承方式] 基类名标识符
{
[访问控制修饰符]
[成员声明列表]
};

继承方式有3种,分别为公有型,保护型和私有型,访问控制修饰符也是public,protected,private 类型。
成员声明列表中包含类成员变量以及成员函数,是派生类新增的成员。
“:”是一个运算符,表示基类和派生类之间的继承关系。

C++中的继承有以下几种类型:

公有继承(public inheritance):派生类继承了基类的公有成员和保护成员,并且这些成员在派生类中的访问权限与基类中的一样。派生类的对象可以直接访问基类的公有成员。

私有继承(private inheritance):派生类继承了基类的公有成员和保护成员,但是这些成员在派生类中的访问权限变为私有。派生类的对象不能直接访问基类的公有成员,只能通过派生类的成员函数来间接访问。

保护继承(protected inheritance):派生类继承了基类的公有成员和保护成员,但是这些成员在派生类中的访问权限变为保护。派生类的对象不能直接访问基类的公有成员,只能通过派生类的成员函数来间接访问。

在C++中,使用关键字class或struct来定义一个类,并使用关键字public、private或protected来指定成员的访问权限。

下面是一个简单的继承示例:

class Shape {
public:
    void draw() {
        std::cout << "Drawing a shape" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

int main() {
    Shape shape;
    shape.draw();  // 输出:"Drawing a shape"

    Rectangle rectangle;
    rectangle.draw();  // 输出:"Drawing a rectangle"

    return 0;
}

在上面的示例中,Shape类是基类,它有一个公有成员函数draw。Rectangle类是派生类,通过public关键字继承了Shape类。Rectangle类重写了draw函数,实现了自己的绘制行为。在main函数中,我们分别创建了Shape对象和Rectangle对象,并调用了它们的draw函数。

继承是一种强大的代码复用工具,它可以使得类之间的关系更加清晰和有组织。通过继承,派生类可以继承基类的接口和实现,并且可以添加自己的功能或修改基类的行为。

继承是面对对象的主要特性之一,它使一个类可以从现有类中派生,而不必重新定义一个类。

实质:用已有的数据类型创建新的数据类型,并保留已有数据类型的特点,以旧类为基础创建新类,新类包含旧类的数据成员和成员函数。并且·可以在新类中添加新的数据成员和成员函数。
旧类被称为基类或者父类,新类被称为派生类或者子类。

多态

C++中的多态是面向对象编程的一个重要概念,它允许使用指针或引用来处理不同类型的对象,而实际上执行的是根据对象类型动态选择的相关操作。多态性可以提高代码的灵活性、可复用性和可扩展性。

C++中的多态性主要通过虚函数(virtual function)和运行时类型识别(runtime type identification)两个机制来实现:

虚函数:在基类中声明虚函数,并在派生类中进行重写。当通过指向基类的指针或引用调用虚函数时,将根据实际对象的类型来选择正确的函数实现。这种动态选择函数的机制称为动态绑定(dynamic binding)。虚函数通过关键字virtual进行声明。

运行时类型识别(RTTI):C++提供了dynamic_cast和typeid两个运算符来进行运行时类型识别。dynamic_cast用于将基类指针或引用转换为派生类指针或引用,如果转换成功,返回指向派生类的指针或引用;如果转换失败,则返回空指针或抛出bad_cast异常。typeid用于获取表达式的实际类型。

下面是一个简单的多态示例:

#include <iostream>

class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

int main() {
    Shape* shapePtr;

    Rectangle rectangle;
    Circle circle;

    shapePtr = &rectangle;
    shapePtr->draw();  // 输出:"Drawing a rectangle"

    shapePtr = &circle;
    shapePtr->draw();  // 输出:"Drawing a circle"

    return 0;
}

在上面的示例中,Shape类有一个虚函数draw,Rectangle和Circle类分别是派生自Shape的两个子类,并重写了draw函数。在main函数中,我们使用指向基类的指针shapePtr来处理不同类型的对象。通过将shapePtr指向Rectangle对象和Circle对象,并调用draw函数,会根据对象的实际类型选择正确的函数实现。

多态性使得我们可以以一种统一的方式来处理不同类型的对象,而不需要关心对象的具体类型。这样可以使代码更具灵活性和可维护性,同时提供了一种机制来实现运行时的动态行为。

多态的实现

静态绑定:在编译期决定
函数重载
运算符重载
模板
动态绑定:在程序运行时执行
虚函数

虚函数概念:

在基类中冠以关键字virtual的成员函数
定义:
virtual函数类型 函数名称(参数列表)
如果一个函数在基类中被声明为虚函数,则它在所有派生类中都是虚函数。
只有通过基类指针或引用调用虚函数才能引发动态绑定
虚函数不能声明为静态
如果一个类要做为多态基类,要将析构函数定义为虚函数

虚表指针

虚函数的动态绑定是通过虚表来实现的
包含虚函数的类头4个字节存放指向虚表的指针

overload

成员函数被重载的特征:
相同的范围(在同一类中)
函数名字相同
参数不同
virtual关键字可有可无

overwrite

覆盖是指派生类函数覆盖基类函数 特征是:
不同的范围
函数名字相同
参数相同
基类函数必须有virtual关键字

override

重定义(派生类与基类)
不同的范围(分贝位于派生类和基类)
函数名与参数都相同,无virtual关键字
函数名相同,参数不同,virtual可有可无

抽象类

作用:
抽象类作为抽象设计的目的而声明,将有关的数据和行为组织在一个继承层次结构中,保证派生类具有要求的行为。
对于暂时无法实现的函数,可以声明为纯虚函数,留给派生类去实现
注意:
抽象类只能作为基类来使用
不能声明抽象类的对象,可以使用抽象类的指针和引用
构造函数不能是虚函数,析构函数可以是虚函数
可以试用指向抽象类的指针支持运行时多态性
派生类中必须实现基类中的纯虚函数,否则被看做一个抽象类

对于一个没有任何接口的类,如果想要将它定义成抽象类,只能将虚构函数声明为纯虚的
通常情况下在基类中纯虚函数不需要实现,例外是纯析构函数要给出实现

重载

在C++中,函数重载(Function Overloading)是指在同一个作用域内,可以定义多个具有相同名称但参数列表不同的函数。通过函数重载,可以根据参数的类型、顺序和个数来区分不同的函数,并且可以为相同的操作提供不同的实现。

函数重载的特点如下:

函数名称相同:重载的函数必须具有相同的名称。

参数列表不同:重载的函数必须具有不同的参数列表,可以通过参数的类型、顺序和个数的不同来区分。

返回值类型不同不足以实现函数重载:函数的返回值类型不能作为重载函数的区分标准,因为函数调用时通常会忽略返回值。

举例如下所示:

#include<iostream>
using namespace std;

class interage
{
    int inter;
    public:
        interage(int in)
        {
            inter = in;
        };
        ~interage(){};
        interage& operator++()
        {
            ++inter;
            return *this; 
        }
        interage operator++(int in)
        {
            interage temp(inter);
            inter++;
            return temp;
        }

        void display()
        {
            cout<<inter<<endl;
        }

};
int main()
{
    interage in(10);
    in.display();
    interage in2 = ++(++in);
    in2.display();
    
    interage in3 = in2++;
    in3.display();
    in3.display();
    return 0;
}

通过函数重载,我们可以在C++中实现更加灵活和易于使用的代码。函数重载允许我们使用相同的函数名,但根据参数的类型、顺序和个数来区分不同的函数。这样,我们可以提供不同的函数实现来处理各种情况,而无需为每种情况编写不同的函数名称。

函数重载使得代码更具可读性和可维护性,同时提供了一种方便的方式来进行函数扩展和适应不同的需求。然而,在使用函数重载时,需要注意避免产生歧义或混淆,确保函数之间的区分明确。

总而言之,函数重载是C++中一个强大的特性,可以使代码更加灵活和易于使用,为我们提供了更多的选择和可能性。合理地利用函数重载,可以使我们的代码更加清晰、高效,同时提高开发效率和代码的可维护性。

文章来源:https://blog.csdn.net/2202_75623950/article/details/134346168
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。