C++基础（二）

最新推荐文章于 2023-09-12 15:34:15 发布

AphilGuo

最新推荐文章于 2023-09-12 15:34:15 发布

阅读量745

点赞数

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

本文链接：https://blog.csdn.net/qq_44798484/article/details/125711355

版权

本文深入探讨了C++的基础知识，包括this指针的使用、静态函数与对象数组的交互、常对象的概念以及static静态成员函数。此外，还详细讲解了友元函数和友元类在C++中的作用，以及如何通过运算符重载实现自定义操作。文章进一步讨论了继承机制，如类继承、接口类和菱形继承，并介绍了构造函数初始化列表、类型转换以及多态性的重要性，特别是纯虚函数在实现多态中的关键角色。

摘要由CSDN通过智能技术生成

this指针

#include <iostream>

using namespace std;

class Stu
{
   
private:
    string name;
    int age;
public:
    Stu(){
   }
    ~Stu(){
   }
    Stu(string name, int age)
    {
   
        this->name = name; //区分参数中的变量和类内变量,形参变量名与类中变量名相同，用于区别类中的属性变量和形参。
        this->age = age;
    }

    Stu& setName(string name) //使用this返回本对象
    {
   
        this->name = name;
        return *this;
    }

    void showInfo()
    {
   
        cout<<"学生信息: \n"<<"name: "<<this->name<<"\nage: "<<this->age<<endl;
    }
};

int main()
{
   
    Stu s("zhangsan", 20);
//    Stu s1 = s.setName("list"); // 返回值为对象时，调用拷贝构造
    s.showInfo();
    Stu s1 = s.setName("list");
    s1.showInfo();
    cout << "Hello World!" << endl;
    return 0;
}



/*
 * this指针
 * 1、指向本对象
 * this本身就是一个编译器提供的指针，指针保存的是本对象的地址
 * 2、返回本对象
 * 3、this不占内存空间
 * 4、this保存本对象的地址。
 * 5、类的成员函数中，静态函数没有this指针；产生对象以后，
 * 编译器才分配的一个指针；static修饰的函数，相当于是进程
 * 加载静态区时，就已经存在的函数，则这个函数时存在于静态区的
 * 而非动态区，是先于对象前产生的，所以它的函数参数中没有this指针。
 * 也就是说这个静态函数，是没办法调用类中非静态成员。因为它没有this指针。
 *
 * this的作用域是在类的内部，当在类的非静态成员函数中，访问类的非静态成员时
 * 编译器会自动将对象本身的地址作为隐藏参数传递给函数。即使没写this指针，编译器也会生成
 * this指针作为非静态成员函数的隐含参数，对各成员的访问都是this指针进行的。
 *
 * 在成员函数内部，我们可以直接调用该函数的对象成员，而无需通过成员访问运算符来做到这一点
 * 因为this所指向的正是这个对象。任何对类成员的访问都被看成this的隐式使用。
 *
 * static修饰的对象时先于对象的，所以形参中时没有this的，所以没有办法调用类中的属性
*/

静态函数

#include <iostream>

using namespace std;

class Stu
{
   
private:
    string name;
    int age;
    static int amount;
public:
    Stu()
    {
   
        cout<<"无参构造"<<endl;
    }
    ~Stu()
    {
   
        cout<<"析构"<<endl;
    }
    Stu(string name, int age)
    {
   
        this->name = name;
        this->age = age;
    }
    static int getAmount()  //没有生成对象时也可使用
    //不需要依赖某个实例，satic修饰的属于整个类，静态函数只能访问静态成员函数
    {
   
        return amount;
    }

    int getAmount123()
    {
   
        return amount;
    }

};
// 类内成员只是声明；类外定义
int Stu::amount = 100;
int main()
{
   
    cout<<Stu::getAmount()<<endl; //被静态函数修饰的函数，是属于本文件的，且不可被external引申，本文件的全局函数
    Stu stu;
    cout<<stu.getAmount123()<<endl;
    cout<<stu.getAmount()<<endl;
    return 0;
}

/*
 * 静态函数与普通函数区别：
 *  用static修饰的函数与其修饰的变量不同，static修饰的函数不是声明存储形式
 * 是修饰的作用域，这个作用域就是本文件使用，相当于本文件使用的全局函数，全
 * 局函数不依赖于某个对象，在没有对象情况下也是可以调用的，这个全局函数没有
 * this指针，所以没办法在静态函数内部访问类中的属性，静态函数时本文件的全局函数
 * 且只有类内可见，这函数可以在没有类对象时访问。
 *
 * 静态函数有点：
 *  1、其他文件中定义同名函数，不会产生冲突
 *  2、静态函数不能被其他文件所用。
 *  3、属于类的，不创建对象也可以使用
 *  4、全局，不依赖对象，没有this指针，无法调用类中属性
 * 普通成员函数
 *  1、在函数参数列表中隐藏了一个this指针，是可以访问类中属性，但是其依赖类对象
 */

对象数组

#include <iostream>

using namespace std;

class Desk
{
   
public:
    Desk()
    {
   
        cout<<"Desk构造"<<endl;
    }
    ~Desk()
    {
   
        cout<<"Desk析构"<<endl;
    }
};

class Chair
{
   
public:
    Chair()
    {
   
        cout<<"Chair的构造"<<endl;
    }
    ~Chair()
    {
   
        cout<<"Chair的析构"<<endl;
    }
};

class Room
{
   
private:
    Desk _desk[3]; //对象数组,每个数组元素都是对象
    Chair _chair[3];
public:
    Room()
    {
   
        cout<<"Room的构造"<<endl;
    }
    ~Room()
    {
   
        cout<<"Room的析构"<<endl;
    }
};

int main()
{
   
    Room room;
    cout << "Hello World!" << endl;
    return 0;
}

/*
 * 当类中有对象时，类内对象先构造，然后构造本对象，如果析构
 * 则先析构本对象，再析构类内对象
 * 当本类中有多个类成员对象时，构造的顺序时先构造类中的对象
 * 构造类中的顺序与声明顺序相同，析构时相反。
*/

常对象

#include <iostream>

using namespace std;

class Key
{
   
public:
    Key()
    {
   
        cout<<"Key的构造"<<endl;
    }
    ~Key()
    {
   
        cout<<"Key的析构"<<endl;
    }
};

class Mouse
{
   
public:
    Mouse()
    {
   
        cout<<"Mouse的构造"<<endl;
    }
    ~Mouse()
    {
   
        cout<<"Mouse的析构"<<endl;
    }
};

class Master
{
   
public:
    int weight;
};

class Computer
{
   
private:
    Key _key;
    Mouse _mouse;
    string name;
public:
    Computer():name("Dell")
    {
   
        cout<<"Computer的构造"<<endl;
    }
    ~Computer()
    {
   
        cout<<"Computer的析构"<<endl;
    }
    string getName() const
    {
   
        return this->name;
    }
    const Computer& setName(string name) //返回类对象
    {
   
        this->