c++学习笔记-6

最新推荐文章于 2024-07-22 10:02:43 发布

lonlybrave

最新推荐文章于 2024-07-22 10:02:43 发布

阅读量43

点赞数

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

本文链接：https://blog.csdn.net/weixin_57791493/article/details/129231346

版权

01.智能指针类（重点）

1.智能指针类是管理另一个类的对象的释放


class Maker
{
public:
    Maker()
    {
        cout << "无参构造" << endl;
    }
    void printMaker()
    {
        cout << "hello Maker" << endl;
    }
    ~Maker()
    {
        cout << "析构函数" << endl;
    }
};

class SmartPoint
{
public:
    SmartPoint(Maker *m)
    {
        this->pMaker = m;
    }

    ~SmartPoint()
    {
        if (this->pMaker != NULL)
        {
            cout << "SmartPoint 析构函数" << endl;
            delete this->pMaker;
            this->pMaker = NULL;
        }
    }
private:
    Maker *pMaker;
};
void test01()
{
    Maker *p = new Maker;

    SmartPoint sm(p);//栈区，会调用析构函数
    //当test01()函数结束时，会调用SmartPoint的析构函数，
    //在这析构函数中delete了Maker的对象，会调用Maker的析构函数

}

2.指针运算符重载

    //重载指针运算符
    Maker *operator->()
    {
        return this->pMaker;
    }
    
    
void test02()
{
    Maker *p = new Maker;

    SmartPoint sm(p);
    //sm-> ==> pMaker->
    sm->printMaker();


}

3.重载星花

//重载星花
    Maker &operator*()
    {
        return *pMaker;
    }
    
void test02()
{
    Maker *p = new Maker;

    SmartPoint sm(p);

    (*sm).printMaker();

}

02.重载函数调用符号（重点）

1.类里有重载函数调用符号的类实例化的对象也叫仿函数

2.仿函数的作用：1.方便代码维护 2.方便有权限的调用函数。3.作为算法的策略（后将）

//一个类如重载了函数调用符号，那么这个类实例化出的对象也叫仿函数
//仿函数的作用：1.方便代码维护 2.方便有权限的调用函数。3.作为算法的策略（后将）
class Maker
{
public:
    Maker()
    {
        name = "翠花";
    }
    void printMaker()
    {
        cout << name + "你好漂亮" << endl;
    }

    void operator()()
    {
        cout << "hello" << endl;
    }

    void operator()(int v1,int v2)
    {
        cout << v1+v2 << endl;
    }
public:
    string name;
};


void test()
{
    Maker func;

    func();//看起来像函数，其实func是对象

    func(10, 20);

    func.printMaker();
}

03.其他重载的重载（了解）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Maker
{
public:
    Maker()
    {
        a = 0;
    }

    void SetA(int val)
    {
        a = val;
    }
    //没有返回值，也没有void
    operator bool()
    {
        if (a <= 0)
        {
            return false;
        }

        return true;
    }

    bool operator!()
    {
        if (a <= 0)
        {
            return true;
        }

        return false;
    }

    operator int()
    {
        return 10;
    }
public:
    int a;
};

void test()
{
    Maker m;
    m.SetA(10);
    if (m)
    {
        cout << "真" << endl;
    }
    else
    {
        cout << "假" << endl;
    }

    if (!m)
    {
        cout << "真" << endl;
    }
    else
    {
        cout << "假" << endl;
    }

    int b = (int)m;
    cout << b << endl;
}
int main()
{
    test();
    system("pause");
    return EXIT_SUCCESS;
}

04.字符串类（了解）

1.目的：设置一个类，类似于string的效果

05.继承的作用（重点）

1.代码复用，2.扩展类的功能

06.继承方式（重点）

1.继承方式，公有继承，私有继承，保护继承

2.子类对从父类继承过来的成员的权限

1.公有继承

1.父类的公有属性成员，到子类还是公有 2.父类的私有属性成员，到子类不能访问 3.父类的保护属性成员，到子类还是保护

2.保护继承

1.父类的公有属性成员，到子类是保护 2.父类的私有属性成员，到子类不能访问 3.父类的保护属性成员，到子类还是保护

3.私有继承

1.父类的公有属性成员，到子类还是私有 2.父类的私有属性成员，到子类不能访问 3.父类的保护属性成员，到子类还是私有

07.继承中的对象模型工程（了解）

1.打开开发者命令程序

如果要跨盘符，还要再次输入盘符名:

3.输入命令:cl /d1reportSingleClassLayout类名文件名

08.继承中的构造和析构（重点）

1.继承中的构造和析构调用顺序

先调用父类的构造函数，再调用本身的构造函数，析构函数调用顺序反之

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

class Son :public Father
{
public:
    Son()
    {
        cout << "Son构造函数" << endl;
    }
    ~Son()
    {
        cout << "Son析构函数" << endl;
    }
};
//先调用父类的构造函数，再调用本身的构造函数，析构函数调用顺序反之
void test01()
{
    Son s;
}

2.继承和组合混搭

先调用父类的构造，然后调用成员对象的构造，最后调用本身的构造，析构函数调用顺序反之

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

};

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

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

class D:public A
{
public:
    D()
    {
        cout << "D 的构造" << endl;
    }
    ~D()
    {
        cout << "D 的析构" << endl;
    }
public:
    B b;
    C c;
};
void test02()
{
    D d;
}

09.继承中同名成员的处理方法（重点）

1.通过父类名加作用域来访问，当子类和父类有同名成员时，子类的同名成员会隐藏父类的同名成员

//当子类和父类有同名成员时，子类的同名成员会隐藏父类的同名成员
void test()
{
    Son s;
    cout << s.a << endl;
    cout << sizeof(Son) << endl;//8
    //通过父类名加作用域来访问
    cout<<s.Father::a << endl;
}

2.当子类有和父类同名函数时，父类的所有重载函数都会被隐藏

class Father
{
public:
    Father()
    {
        a = 10;
    }

    void func()
    {
        cout << "Father func" << endl;
    }
    void func(int a)
    {
        cout << "Father func(int a)" << endl;
    }

    void func(int a,int b)
    {
        cout << "Father func(int a,int b)" << endl;
    }


public:
    int a;
};
class Son :public Father
{
public:
    Son()
    {
        a = 20;
    }
    void func()
    {
        cout << "Son func" << endl;
    }
public:
    int a;
};

//当子类有和父类同名函数时，父类的所有函数重载都会被隐藏
void test02()
{
    Son s;
    s.func();
    //s.func(10);err
    //s.func(10, 20);err
}