C++基础面向对象特征

于 2024-08-29 19:58:22 发布
阅读量853 收藏 14
点赞数 29
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50357983/article/details/141674833
版权

目录

学习目标：

学习内容：

1. C++对函数的扩充

1.1 函数重载（overload）

1.1.1 概念

1.1.2  要求

1.2 函数的默认参数 

1.3 哑元 

1.4 内联函数

        内联函数与带参宏的区别 (重要)

2. 封装

2.1 面向对象的三大特质

2.2 C++中的类（class）

2.3 定义格式

2.4 this指针 

2.5 类的大小 

3. 类中特殊的成员函数（非常重要） 

3.1 类中提供的特殊成员函数

3.2 构造函数

3.3 析构函数 

课外作业：

仿照string类，实现myString

学习目标：

学习内容：

1. C++对函数的扩充

1.1 函数重载（overload）

1.1.1 概念

        函数重载就是能够实现"一名多用"，是实现泛型编程的一种

        泛型编程：试图以不变的代码，来实现可变的功能

        C++引入了函数重载：运行在同一个作用域下，定义多个同名的函数。但是，要求这些同名的函数必须参数参数不同，后期调用时，系统会根据主调函数的实参去自动匹配相应的函数执行。

1.1.2  要求

        函数名相同

        形参列表必须不同

        返回值无关

        必须在同一个作用域下

#include <iostream>


using namespace std;


//定义两个整数的求和
int sum(int m, int n)
{
    return m+n;
}


//下面这个函数会报错，即使函数返回值和函数体内容不同，也不能构成重载
//void sum(int m, int n)
//{
//    return m-n;
//}


//定义两个小数的求和
float sum(float m, float n)
{
    return  m+n;
}


//定义两个double类型的数据求和
double sum(double m, double n)
{
    return m+n;
}


//定义三个整数的求和
int sum(int m, double n, int k)
{
    return m+n+k;
}


int main()
{
    cout<<sum(3,7)<<endl;        //10




    cout<<sum(3.5,7.5)<<endl;        //11


    cout<<sum(3,7.5, 6)<<endl;   //16


    return 0;
}

1.2 函数的默认参数 

        1. C++允许在定义函数时，给其中的某几个参数设置默认参数，对于设置了默认值的参数，主调函数传数据就使用主调函数传的，主调函数不传数据，就使用默认值

        2. 默认参数的设置原则：靠右原则，也就是说必须当前参数的右边的形参设置了默认值后，当前参数才能设置默认值。

        原因是，函数参数传递的过程是靠左原则，实参向形参传递时，向给左侧的形参赋值

        3. 当函数重载和默认参数同时出现时，注意，如果带默认参数的函数包含了重载的函数，那么函数定义时没有问题，但是函数版调用时会不确定调用哪一个

        4. 如果带默认参数的函数，声明和定义分开时，默认参数写在声明部分，定义部分就不写默认参数了

#include <iostream>


using namespace std;


int sum(int  = 0, int =0, int =100);    //函数声明


//定义重载函数时
//int sum(int x, int y):如果有默认参数包含了该函数，函数定义是没有问题，但是函数调用时会不知道调用哪一个
int sum(int x, double y)
{
    return x+y;
}




int main()
{
    cout << sum(2,3,5) << endl;       //调用了默认参数的函数，三个参数主调函数传递


    cout << sum(2,3) << endl;       //调用了默认参数的函数，前两个参数主调函数传递，后一个参数使用默认的


    cout << sum(2) << endl;       //调用了默认参数的函数，前一个参数主调函数传递，后两个参数使用默认的


    cout << sum() << endl;        //调用了默认参数的函数，三个参数使用的都是默认值


    return 0;
}


//函数定义在被调函数后面
int sum(int m , int n, int k)
{
    return m+n+k;
}

1.3 哑元 

        1> C++定义函数时，支持哑元，运行某个形参或某几个形参只有声明，没有实际意义，唯一的作用就是起到占位作用

#include <iostream>


using namespace std;


//该函数中的参数2就是一个哑元，只起到占位作用，不让程序优化后报错
int sum(int m, int, int k)
{
    return m+k;
}






int main()
{
    cout << sum(2,3,5) << endl;
    cout << sum(2,3,5) << endl;

    return 0;
}

        2> 使用场景1：当某个程序已经发布后，随着技术的升级，可能会对某些函数进行优化，将原本有多个参数的函数，只需要少了的参数就可以完成，但是此时，未优化前的函数已经被多次调用，修改起来不方便，此时就可以在定义函数时，将被优化掉的形参设置成哑元，只起到接受数据的作用，并不起实际作用

        3> 使用场景3：后期学习自增自减运算符重载时，用于区分前置和后置

1.4 内联函数

        1> C++支持内联函数，使用关键字inline在函数定义前使用

        2> 作用：被设置成内联函数的函数，在编译时，编译器会建议将内联函数自动展开，无需在运行时为该函数开辟内存空间，提高程序的执行效率

        3> 内联函数的设置要求：

                1、函数体积要小

                2、调用比较频繁的函数

                3、递归函数不能设置成内联函数

                4、不足：如果大量使用内联函数，会使得主程序体积膨胀

#include <iostream>


using namespace std;


//该函数中的参数2就是一个哑元，只起到占位作用，不让程序优化后报错
inline int sum(int m, int, int k)
{
    return m+k;
}

int main()
{
    cout << sum(2,3,5) << endl;
    cout << sum(2,3,5) << endl;

    return 0;
}

        内联函数与带参宏的区别 (重要)

在C++中，内联函数和带参宏虽然都可以用来在编译时展开代码以减少函数调用的开销，但它们之间存在几个关键的区别：

1. 类型检查
内联函数：内联函数是真正的函数，支持类型安全，会进行类型检查。
带参宏：宏只是预处理器的文本替换工具，不进行类型检查，容易引发类型相关的错误。

2. 编译器优化
内联函数：内联函数允许编译器进行更多优化，比如常量折叠、死代码消除等。
带参宏：宏展开后的代码通常不会受到这些优化的好处，因为它们在预处理阶段就已经被处理了。

3. 调试
内联函数：在调试时，内联函数可以像普通函数一样进行单步调试。
带参宏：宏在预处理阶段就已经被展开，这使得调试变得困难，因为它们在源代码中不再是独立的实体。

4. 作用域
内联函数：内联函数遵循正常的作用域规则。
带参宏：宏没有作用域的概念，它们可以在定义后的任何地方被展开，有时会导致意外的名字冲突。

5. 重复代码
内联函数：内联函数的代码在多个调用点展开时，编译器可以智能地处理，避免不必要的代码膨胀。
带参宏：宏每次使用时都会文本上的复制粘贴，可能会导致代码膨胀。

2. 封装

2.1 面向对象的三大特质

        封装、继承、多态，如果问有四大特征，可以外加一个抽象

                封装：将实现同一事物的所有的属性（成员变量）和行为（成员函数）封装到一个整体，我们称之为类（class）。类对外部信息有一个屏障作用。

2.2 C++中的类（class）

        C++中的类，是由C++中的结构体演化而来的，只需要将struct改成关键字class，就定义了一个类

        C++中类和结构体的区别：默认的权限不同，结构体中默认权限为public，类中默认权限为private

        默认的继承方式不同，结构体的默认继承方式为public，类的默认继承方式为private

2.3 定义格式

class 类名 { public: 功能的成员属性、函数 protected： 受保护的成员属性、函数 private: 私有的成员属性、函数 }；

        1> 类中的成员属性和成员函数分为不同的权限

                public：该权限下的成员，可以在类内、子类中、类外被访问

                protected:该权限下的成员，可以在类内、子类中直接被访问，类外不允许被访问

                private：该权限下的成员，只能在类内被访问，子类、类外不允许被访问

        2> 如果没有指定权限，则默认为私有权限

        3> 一个类中，访问权限可以出现多次，也可以出现在任意地方，一般情况下，我们将同一权限下的成员写到一个关键字下面

        4> 一个访问权限的范围，是从当前关键字开始到下一个关键字或者整个类的定义结束为止

        5> 一般情况下，成员属性定义成私有的，成员函数定义成公有的

        6> 类的访问权限是针对于类体而言的，不是针对于类对象的

#include <iostream>


using namespace std;


//将实现人的所有属性和行为都封装到一个整体，
//后期如果需要一个人，只需要使用该类实例化对象后，通过对象为整个程序服务
class Person
{
    string skill = "C++";          //技能


public:
    string name = "zhangsan";        //姓名    功能的属性


protected:
    int pwd = 123456;           //银行卡密码


private:
    int money = 1000000;         //私房钱


public:
    void show()
    {
        cout<<"  name = "<<name<<endl;        //公共权限下的成员，类内可以直接访问
        cout<<"  pwd = "<<pwd<<endl;          //受保护权限下的成员，类内可以直接访问
        cout<<"  money = "<<money<<endl;      //私有成员，类内可以直接访问
        cout<<"  skill = "<<skill<<endl;      //默认为私有成员，类内可以直接访问
    }


};


/******************************************主程序***************************/
int main()
{
    Person p1;          //使用类定义变量的过程，称为实例化对象，p1就是Person类的一个对象


    //通过p1使用成员
    cout<<"name = "<<p1.name<<endl;          //公共权限下的成员，类外可以直接访问
    //cout<<"pwd = "<<p1.pwd<<endl;            //收保护成员，类外无法直接访问
    //cout<<"money = "<<p1.money<<endl;      //私有成员，类内可以直接访问,类外无法访问
    //cout<<"skill = "<<p1.skill<<endl;      //默认为私有成员，类内可以直接访问，类外无法访问
    p1.show();                                 //类中公共权限下的成员，类外可以直接访问


    return 0;
}

2.4 this指针 

        1> this的内含：是类的非静态成员函数所拥有的一个隐藏的形参指针，指代该对象本身起始地址，哪个对象使用我，我就表示哪个对象

        2> this指针的格式：类名 * const this;

        3> 对于this指针而言，如果没有显性使用该指针，仅仅只是使用成员，那也是默认使用了this指针

        4> this指针的使用场景

                场景1：当成员函数的形参名和成员变量同名时，可以使用this指针进行区分

                场景2：在拷贝复制函数中，需要返回自身引用时，也必须使用this指针（后面讲）

#include <iostream>


using namespace std;
class rectangle
{
public:
    void init(int width, int height);       //初始化一个矩形

    void show()
    {
        cout<<"width = "<<width<<"  height = "<<height<<endl;
    }
private:
    int width=0;             //矩形宽度
    int height=0;             //矩形高度
};


void rectangle::init(int width, int height)
{
    if(width<=0 || height<=0)
    {
        cout<<"初始化失败"<<endl;
    }
    this->width = width;             //可以通过this指针改变this所指向内存中的值
    this->height = height;


    cout<<"this = "<<this<<endl;


    //this = NULL;          //不能更改指针的指向


}


int main()
{
    //使用矩形类实例化一个矩形
    rectangle r1;            //实例化一个对象
    r1.init(3,5);          //初始化一个矩形
    cout<<"&r1 = "<<&r1<<endl;         //r1的地址
    r1.show();

    //在实例化一个对象
    rectangle r2;
    r2.init(2,2);
    cout<<"&r2 = "<<&r2<<endl;         //r2的地址

    return 0;
}

2.5 类的大小 

        1> 一个空的类的大小为1字节，用于占位使用，如果后期有成员变量的加入，则会将这一字节的空间分配出去

        2> 类中的成员函数不占类的空间大小，但是成员属性会占用类的大小

        3> 成员属性分配空间的大小遵循字节对齐原则

        4> 如果类中有虚函数（后期讲），那么类中就会多一个虚指针的大小

        5> 如果该类是虚继承（后期讲）自父类，那么该类中也会增加一个虚指针的大小

#include <iostream>


using namespace std;


class Temp
{
public:
    int num;      //整型成员变量


    void show()
    {
        cout<<"num = "<<num<<endl;
    }


    //类中有虚函数时，就会多分配一个虚指针的空间
    virtual void display()
    {
        cout<<"我是虚函数"<<endl;
    }


    virtual void display(int )
    {
        cout<<"我是虚函数"<<endl;
    }


};


int main()
{
    cout<<"sizeof(Temp) = "<<sizeof(Temp)<<endl;

    return 0;
}

3. 类中特殊的成员函数（非常重要） 

3.1 类中提供的特殊成员函数

        1> 特殊的原因：如果用户不显性定义这些函数，系统也会自动提供这些函数，如果用户显性定义了这些函数，那么系统就不提供了。

        无论这些特殊的成员函数，是系统提供的还是用户字节定义的，都无需用户手动调用，特殊的时机，系统会自动调用

        2> 构造函数、析构函数、拷贝构造函数、拷贝复制函数、移动构造函数、移动复值函数、取地址运算符重载

3.2 构造函数

        1> 功能：使用类去实例化对象时，为对象进行资源的申请以及初始化使用的

        2> 定义格式

                1、构造函数没有返回值

                2、函数名与类同名

                3、访问权限，一般为public

                4、 类名(形参列表){函数体内容}

        3> 调用时机：当使用类实例化对象时，系统自动调用，无需手动调用

                1、栈区空间：使用类实例化对象时，系统自动调用

                        类名 变量名(实参)； //此时就调用的构造函数

                2、堆区空间：只有在使用new申请空间时，自动调用构造函数

                        类名 *指针名； //此时仅仅只是定义一个指针变量，并没有为对象分配空间

                        指针名 = new 类名(实参); //此时调用的构造函数

#include <iostream>


using namespace std;


class Stu
{
public:
    Stu()
    {
        cout<<"Stu的构造函数"<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;


    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    return 0;
}

        4> 构造函数分为有参构造和无参构造函数，有参构造函数可以为成员属性进行初始化，这些构造函数之间构成重载关系

        5> 一个类中可以有多个构造函数，每个对象仅仅只会调用一个构造函数

        6> 如果类中没有定义构造函数，那么，系统会自动提供一个无参构造函数，用于对对象空间的申请，如果程序员自己定义了构造函数，系统就不再提供那个无参构造了，如果还想使用无参构造，需要自己定义一个无参构造

 

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;


public:
    //无参构造
    Stu()
    {
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a)
    {
        this->name = n;
        this->age = a;
        cout<<"Stu::有参构造"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;


    //申请一个对象，调用有参构造
    Stu s2("zhangsan", 18);          //此时调用了有参构造
    s2.show();
    cout<<"**************************************"<<endl;


    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    return 0;
}

        7> 构造函数初始化对象可以使用初始化列表完成

                使用方式：类名（形参1，形参2，。。。形参n）:成员1（形参1），成员2（形参2），。。。成员n(形参n){函数体内容}

                说明：在构造函数的小括号后，由冒号引出初始化列表，括号外时成员变量，括号内是形参

 

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;


public:
    //无参构造
    Stu()
    {
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }


    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string n, int a, double s):name(n),age(a),score(s)
    {
        cout<<"Stu::有参构造2"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;


    //申请一个对象，调用有参构造
    Stu s2("zhangsan", 18);          //此时调用了有参构造
    s2.show();
    cout<<"**************************************"<<endl;




    //申请一个对象，调用有参构造
    Stu s3("lisi", 20, 99.8);
    s3.show();
    cout<<"**************************************"<<endl;




    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    return 0;
}

        8> 必须使用初始化列表的情况

                1、当构造函数的形参名和成员变量名同名时，可以使用初始化列表来解决

                2、当类中有const修饰的成员变量时，对该变量也必须进行初始化，使用初始化列表解决

                3、当类中有引用成员时，对该成员的操作也必须使用初始化列表完成

                4、当类中有其他类的成员子对象时，对该成员的操作也必须使用初始化列表完成，如果没有使用初始化列表调用有参构造，则系统会自动调用成员子对象的无参构造

 

#include <iostream>


using namespace std;


class Toy
{
public:
    Toy() {cout<<"Toy::无参构造"<<endl;}
    Toy(string n):name(n) {cout<<"Toy::有参构造"<<endl;}


private:
    string name;


};






class Stu
{
private:
    string name;
    int age;
    double score;
    const int value;        //类中有const类型的成员
    int &key;             //类中有引用成员
    Toy t;               //类中有其他类的成员子对象


public:
    //无参构造
    Stu():value(1314), key(*(new int(520))), t("hello kity")
    {


        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a, int &k):value(1314), key(k)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }


    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string name, int age, double score, int &k):name(name),age(age),score(score),value(1314),key(k)
    {
        cout<<"Stu::有参构造2"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};


int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;

    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数

    return 0;
}

3.3 析构函数 

        1> 功能：在对象消亡时，用于给对象回收空间使用的

        2> 定义格式

1、没有返回值
2、函数名：类名前加个波浪线  ~类名
3、权限：一般为public
4、没有参数，所以，一个类中只有一个析构函数，不能进行重载
5、格式：   ~类名();

        3> 调用时机：当对象的生命周期结束后，用于回收内存空间

                栈区：当栈空间释放后，系统会自动调用该类的析构函数

                堆区：当使用delete关键字释放对象空间时，系统自动调用

        4> 如果没有手动定义析构函数，系统会提供一个析构函数，用于回收类对象的空间，如果手动定义了析构函数，那么，系统就不再提供默认的析构函数了。

#include <iostream>


using namespace std;


class Toy
{
public:
    Toy() {cout<<"Toy::无参构造"<<endl;}
    Toy(string n):name(n) {cout<<"Toy::有参构造"<<endl;}


private:
    string name;


};


class Stu
{
private:
    string name;
    int age;
    double score;
    const int value;        //类中有const类型的成员
    int &key;             //类中有引用成员
    Toy t;               //类中有其他类的成员子对象
    int *ptr;         //指针成员


public:
    //无参构造
    Stu():value(1314), key(*(new int(520))), t("hello kity"), ptr(new int(666))
    {


        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a, int &k):value(1314), key(k)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }


    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string name, int age, double score, int &k):name(name),age(age),score(score),value(1314),key(k)
    {
        cout<<"Stu::有参构造2"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }


    //定义析构函数
    ~Stu()
    {
        delete ptr;          //释放指针的空间
        cout<<"STU::析构函数"<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;




    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    //释放ptr的空间
    delete ptr;       //此时会调用析构函数


    return 0;
}

课外作业：

仿照string类，实现myString

解析：

#include <iostream>
#include <string.h>
using namespace std;

class myString
{
private:
    // 指向字符串的指针
    char *str;
    // 字符串的容量
    int size;

public:
    // 默认构造函数：初始化一个空字符串，初始容量为10
    myString():size(10)
    {
        str = new char[size];
    }

    // 构造函数：接受一个const char指针，复制其内容作为新字符串
    myString(const char *s)
    {
        // 获取传入字符串的长度
        size = strlen(s);
        // 分配足够空间存储字符串，包括终止符'\0'
        str = new char[size+1];
        // 复制传入的字符串到新分配的内存中
        strcpy(str,s);
    }
    //析构函数
    ~myString();
    //判空
    bool empty();
    //长度
    int lenth();
    //打印
    char * c_str();
    //拷贝
    myString(const myString &other);
    //指定位置显示
    char &at(int index)
    {
        return str[index];
    }
    //二倍扩容
    void expend();
};

myString::~myString()
{
    for(int i=0;i<size;i++)
    {
        delete [] &str[i];      //循环删除数据
    }
    delete [] str;    //删除表
}

bool myString::empty()
{
    return size==0;       //判空
} 

int myString::lenth()
{
    return size;       //返回字符串长度
}

char *myString::c_str()
{
    return str;        //返回数据
}

myString::myString(const myString &other)
{
    size = other.size;         //将待拷贝的大小覆盖原来的大小
    str = new char[size+1];     //申请空间
    strcpy(str,other.str);        //复制内容到新列表里
}


void myString::expend()
{
    size *=2;
    char *newstr = new char[size];
    strcpy(newstr,str);
    delete [] str;
    str = newstr;
}


int main()
{
    myString q("adsdvbadf");
    myString q1=q;
    cout<<"拷贝:"<<q1.c_str()<<endl;
    cout<<"数据为:"<<q.c_str()<<endl;
    cout <<"长度为："<< q.lenth() << endl;
    cout <<"第3个元素为："<< q.at(2)<<endl;
    return 0;
}

没有百宝袋的哆啦A梦
关注
  • 29
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++基础：面向对象编程
weixin_58368590的博客
05-23 1237
1. 面向过程： 当软件规模超过一定的尺度后，采用结构化程序设计，其开发和维护就越来越难空值。其根本原因就在于面向过程的结构化程序设计的方法与现实世界往往不一致，结构化程序的思想往往很难贯彻到底。 在结构化设计中，往往采用的是“自顶向下，逐步细化”的思想。具体操作方法是模块化，是按照功能来分的，所以也称为功能块（函数）。在c++中称为一个函数，一个函数解决一个问题，即实现一个功能或一个操作。 在模块化的思想中已经出现了封装的概念，这个封装是将数据封装到模块中，即局部变量。电脑这是很不彻底的，因为模块是
C++面向对象基础
stt2019
05-20 2万+
面向对象基础面向对象三大特性封装性：数据和代码捆绑在一起，避免外界干扰和不确定性访问。封装可以使得代码模块化。优点：确保用户代码不会无意间破坏封装对象的状态被封装的类的具体实现细节可以随时改变，而无须调整用户级别的代码继承性：让某种类型对象获得另一个类型对象的属性和方法。继承可以扩展已存在的代码多态性：同一事物表现出不同事物的能力，即向不同对象发送同一消息，不同的对象在接收时会产生不同的行为（重载...
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 64万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
C++面向对象
qq_45806136的博客
02-13 3984
*从存储空间的角度考虑：**构造函数是在实例化对象的时候进行调用，如果此时将构造函数定义成虚函数，需要通过访问该对象所在的内存空间才能进行虚函数的调用（因为需要通过指向虚函数表的指针调用虚函数表，虽然虚函数表在编译时就有了，但是没有虚函数的指针，虚函数的指针只有在创建了对象才有），但是此时该对象还未创建，便无法进行虚函数的调用。所以构造函数不能定义成虚函数。**从使用的角度考虑：**虚函数是基类的指针指向派生类的对象时，通过该指针实现对派生类的虚函数的调用，构造函数是在创建对象时自动调用的。
面向对象程序（C++）设计基础
铁路十六宿舍的博客
02-12 1731
本文由浅入深的对面向对象语言涉及的概念进行了详解，以C++给读者针对重要的概念举例，帮助读者能够快速实现从过程语言（c）到面向对象语言的编程思路转换。
浅谈C++的面向对象
qq_46046431的博客
05-28 3272
文章目录前言如何理解C++面向对象编程封装继承多态拓展：虚函数的一点小规则总结 前言 注：我的笔记风格，可能不会特别官方，不会晦涩难懂，而是以一个初学者能看懂的方式把知识呈现出来，用最简单的语言把抽象的概念表达出来～ 经常谈到面向对象这四个字，那么下面以C++为例，谈一下我对面向对象的理解，请往下看～ 如何理解C++面向对象编程 看以下三点： 1.c++面向对象编程就是把一切事物都变成一个个对象，用属性和方法来描述对象的信息，比如定义一个猫对象，猫的眼睛、毛发、嘴巴就可以定义为猫对象的属性，猫的叫声
C++ 面向对象程序设计
2201_75772333的博客
05-03 3619
在面向对象的思想中，我们把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。当然，一个应用程序会包含多个对象，通过多个对象的相互配合即可实现应用程序所需的功能，这样当应用程序功能发生变动时，只需要修改个别对象就可以了，使代码更容易维护。面向对象的程序设计思想可以帮助我们创建结构良好的，可复用的代码，更好地描述和理解真实世界的问题。封装可以隐藏对象的内部表示，只通过对象的方法暴露必要的操作和功能。这使得新类可以复用和扩展已存在的类的代码，提高了代码的复用性，并能够表达类之间的"is-a"关系。
C++面向对象程序设计基础知识点
Joker700的博客
12-12 2873
在学习过C语言以及c++的基础概念后相信大家对于面向过程的程序设计已经得心应手，那么今天我们所提到的就是c++编程思想中的面向对象程序设计，本篇文章将为大家介绍一些关于C++面向对象程序设计的基础知识点。
C++—面向对象三大特性以及多态重点详解
拥抱技术
06-30 1228
面向对象三大特性、C++多态详解
C++中面向对象的思想
weizheng1000的专栏
04-25 1103
C++语言是C语言的拓展，C语言是面向过程的，C++在C的基础上增加了面向对象的方法。         所谓面向过程的编程思想，就是分析解决问题的步骤，将这些步骤用一个个函数实现，最后一个个调用。         所谓面向对象的编程思想，就是将任何事物都看成一个对象，对象有各种属性(attribute)和行为(behavior)，在解决问题的过程中，将系统分解，使之模块化。   
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
**一、面向对象编程基础** 面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心思想是将数据和操作数据的方法封装在一起，形成对象。C++是支持OOP的重要编程语言，提供了类（Class）、对象...
C++面向对象程序设计_C++_C++面向对象_ppt_
10-04
这个PPT对于初学者来说是一份宝贵的资源，它不仅涵盖了C++面向对象的基础知识，还可能深入到一些高级主题，帮助学习者全面理解并掌握面向对象编程在C++中的实践应用。通过学习和理解这些内容，开发者将能够利用C++的...
《C++面向对象程序设计》第2版编程题答案
02-26
C++是一种强类型、静态类型的编程语言，它在C语言的基础上加入了类、封装、继承、多态等面向对象的特性。面向对象编程是一种将数据和操作数据的方法封装在一起的编程范式，它强调通过对象来表示现实世界中的实体，...
c++ 面向对象设计五大原则
08-18
C++ 面向对象设计五大原则 C++ 面向对象设计五大原则是面向对象编程（OOP）中一个非常重要的...C++ 面向对象设计五大原则是面向对象设计的基础，遵循这五大原则可以使我们的程序设计更加合理、更加灵活、更加可维护。
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
最新发布
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 389
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C++ 重载运算符和重载函数
lly202406的博客
08-25 934
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1784
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
初识顺序表---C语言
weixin_74202161的博客
08-23 678
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
＜C++＞ 多态
prodigy623的博客
08-24 1168
多态的细节
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值