c++学习笔记-4

01.explicit的作用(了解)

class Maker
{
public:
    //explicit只能放在构造函数前面，构造函数只有一个参数或其他参数有默认值时
    explicit Maker(int n)//防止编译器优化Maker m=10;这种格式
    {
​
    }
};
​
int main()
{
    //Maker m = 10;err
}

02.C++的堆区空间的申请和释放（重点）

1.申请和释放变量空间

1.为什么要有新的方法申请和释放堆区空间

因为用C语言的方式不会调用构造和析构函数

2.C++中申请堆区空间和释放堆区空间用什么关键字

申请堆区空间用new,释放空间用delete

class Maker
{
public:
    Maker()
    {
        cout << "构造函数" << endl;
    }
​
    Maker(int a)
    {
        cout << "有参构造函数" << endl;
    }
    ~Maker()
    {
        cout << "析构函数" << endl;
    }
};
​
void test02()
{
    //用new方式申请堆区空间，会调用类的构造函数
    Maker *m = new Maker;
​
    //释放堆区空间，会调用类的析构函数
    delete m;
    m = NULL;
​
    Maker *m2 = new Maker(10);
​
    delete m2;
    m2 = NULL;
}

2.申请和释放数组空间

1.new创建基础类型的数组

void test01()
{
    //申请基础数据类型的数组
    int *pInt = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//不推荐
    for (int i = 0; i < 10; i++)
    {
        pInt[i] = i + 1;
    }
​
    for (int i = 0; i < 10; i++)
    {
        cout << pInt[i] << " ";
    }
​
    cout << endl;
​
    char *pChar = new char[64];
    memset(pChar, 0, 64);
    strcpy(pChar, "小话");
    cout << pChar << endl;
​
    //注意：如果new时有中括号，那么delete时也要有中括号
    delete[] pInt;
    delete[] pChar;
​
}

2.new创建对象数组

class Maker
{
public:
    Maker()
    {
        cout << "构造函数" << endl;
    }
​
    Maker(int a)
    {
        cout << "有参构造函数" << endl;
    }
    ~Maker()
    {
        cout << "析构函数" << endl;
    }
};
​
void test02()
{
    Maker *ms = new Maker[2];//调用无参构造
​
    delete[] ms;
​
    //大部分编译器不支持这种写法，(聚合初始化）
    //Maker *ms2 = new Maker[2]{Maker(10), Maker(20)};
}

3.delete void*可能出错,不会调用对象的析构函数

void test03()
{
    void *m = new Maker;
​
    //如果用void*来接new的对象，那么delete时不会调用析构函数
    delete m;
    //在编译阶段，那么编译器就确定好了函数的调用地址，
    //C++编译器不认识void*,不知道void*指向那个函数，所以不会调用析构函数
    //这种编译方式叫静态联编
}

4.C和C++的申请和释放堆区空间不要混用

3.和C的共同和区别之处

共同：都是申请堆区空间和释放堆区空间

区别：C++的会调用构造和析构函数

03.静态成员（了解）

1.静态成员变量的生命周期是整个程序，作用域在类内

2.静态成员变量要在类内声明，类外初始化

3.静态成员变量属于类，不属于对象，是所有对象共享

4.静态成员变量可以用类访问，也可以用对象访问

class Maker
{
public:
    Maker()
    {
        
    }
public:
    //1.静态成员变量的生命周期是整个程序，作用域在类内
    static int a;
};
//2.静态成员变量要在类内声明，类外初始化
int Maker::a = 100;
void test01()
{
    //3.静态成员变量属于类，不属于对象，是所有对象共享
    cout << Maker::a << endl;
    Maker m;
    cout << m.a << endl;
    //4.静态成员变量可以用类访问，也可以用对象访问
}

5.静态成员函数只能访问静态成员变量

class Maker2
{
public:
    Maker2()
    {
​
    }
    //静态成员函数只能访问静态成员变量
    static void setA(int a)
    {
        a2 = a;
        cout << "a2=" << a2 << endl;
        //a1 = a;不能访问普通成员变量
    }
public:
    int a1;
    static int a2;
};
int Maker2::a2 = 200;
void test02()
{
    Maker2::setA(300);
}

6.静态成员也有权限，如果为私有，类外也不可以访问

class Maker3
{
private:
    static void func()
    {
        cout << "a3=" << a3 << endl;
    }
private:
    static int a3;
};
int Maker3::a3 = 300;
void test03()
{
    //Maker3::func();err
}

7.const修饰的静态成员变量，最好在类内初始化

//const修饰的静态成员变量最好在类内初始化
class Maker4
{
public:
    const static int a = 20;
    const static int b;
};
//类外也可以初始化
const int Maker4::b = 30;

8.普通成员函数可以访问静态成员变量

class Maker5
{
public:
    void func()
    {
        cout << "a=" << a << endl;
    }
public:
    static int a;
};
​
//类外也可以初始化
int Maker5::a = 30;
​
void test04()
{
    Maker5 m;
    m.func();
    
}

04.C++的对象模型（重点）

1.空类的大小是1.

2.类的成员函数不占用类的大小，静态成员变量不占用类的大小，静态成员函数不占用类的大小

3.普通成员变量占用类的大小

4.类的成员中，成员函数和成员变量是分开存储

05.this指针（重点难点）

1.每个对象都有一个隐藏的this指针，但不属于对象，是编译器添加的

2.编译器会把this指针传入成员函数内

3.this指针指向对象的存储空间

4.this的作用:

class Maker2
{
public:
    //1.当形参名和成员变量名相同时，用this指针区分
    Maker2(int id)
    {
        this->id = id;
    }
    //2.返回对象的本身
    Maker2 &getMaker2()
    {
        return *this;//运算符重载时有用
    }
public:
    int id;
};

5.拓展

1.this指针指向的空间有没有存储静态成员变量？

没有

2.this指针的指向可以改变吗？

this指针的指向不能改变，也就是说this是Maker *const this;

6.防止空指针调用成员函数

class Maker
{
public:
    Maker()
    {
        a = 20;
    }
​
    void printMaker()
    {
        if (this == NULL)
        {
            cout << "this==NULL" << endl;
            return;
        }
        
        cout << this->a << endl;
    }
private:
    int a;
};
​
void test()
{
    Maker *m = NULL;
    m->printMaker();
}

06.常函数和常对象（重点）

1.常函数

1.在函数的()后面加上const，这个函数就是常函数

2.常函数内不能修改普通成员变量

3.const修饰的是this指针指向的空间中的变量不能改变

4.mutable修饰的成员变量在常函数中可以修改

class Maker
{
public:
    Maker(int id, int age)
    {
        this->id = id;
        this->age = age;
        score = 100;
    }
    //常函数,1.函数的()后面添加const,该函数是常函数
    void printMaker()const
    {
        //id = 100;err//2.常函数内不能修改普通成员变量
        //3.const修饰的是this指针指向的空间中的变量不能改变
        //Maker *const this;
        //const Maker*const this;这是常函数修饰的
        score = 200;//4.mutable修饰的成员变量在常函数中可以修改
        cout << "score=" << score << endl;
    }
public:
    int id;
    int age;
    mutable int score;//mutable修饰的成员变量
​
};
void test01()
{
    Maker m(1, 18);
    m.printMaker();
}

2.常对象

1.在数据类型前面加上const，让对象成为常对象

2.常对象可以调用常函数

3.常对象可以修改mutable修饰的成员变量

class Maker
{
public:
    Maker(int id, int age)
    {
        this->id = id;
        this->age = age;
        score = 100;
    }
    //常函数,1.函数的()后面添加const,该函数是常函数
    void printMaker()const
    {
        //id = 100;err//2.常函数内不能修改普通成员变量
        //3.const修饰的是this指针指向的空间中的变量不能改变
        //Maker *const this;
        //const Maker*const this;这是常函数修饰的
        score = 200;//4.mutable修饰的成员变量在常函数中可以修改
        cout << "score=" << score << endl;
    }
    void func()
    {
        cout << "func" << endl;
    }
public:
    int id;
    int age;
    mutable int score;//mutable修饰的成员变量
​
};
​
void test()
{
    //1.在数据类型前面加上const，让对象成为常对象
    const Maker m(1, 18);//常对象
​
    //m.id = 100;//常对象不能改变普通成员变量的值
    //m.func();//常对象不能调用普通成员函数
    m.printMaker();//2.常对象可以调用常函数
    m.score = 500;//常对象可以修改mutable修饰的成员变量
​
    Maker m2(2, 20);
    m2.printMaker();//普通对象也可以调用常函数
​
}

07.友元（重点难点）

1.友元的概念

友元是赋予全局函数，类的成员函数，类，访问别的类的私有成员权限

注意：友元函数不是类的成员函数

1.全局友元函数

class Building
{
    //声明这个全局函数为Building类的友元函数
    friend void GoodGay(Building &bd);
public:
    Building()
    {
        keting = "客厅";
        woshi = "卧室";
    }
​
public:
    string keting;
private:
    string woshi;
};
​
void GoodGay(Building &bd)
{
    cout << "好基友访问:" << bd.keting << endl;
    cout << "好基友访问:" << bd.woshi << endl;
}
​
void test01()
{
    Building my;
​
    GoodGay(my);
}

2.友元类

class Building
{
    //声明GoodF类为Building类的友元类
    friend class GoodF;
    friend class GoodF2;
public:
    Building()
    {
        keting = "客厅";
        woshi = "卧室";
    }
​
public:
    string keting;
private:
    string woshi;
};
​
class GoodF
{
public:
    void func(Building &bd)
    {
        cout << "访问:" << bd.keting << endl;
        cout << "访问:" << bd.woshi << endl;//通过参数访问私有成员
    }
};
//1.通过传入参数来访问类的私有成员
void test01()
{
    Building bd;
    GoodF f;
    f.func(bd);
}
​
//2.通过类内指针来访问类的私有成员
class GoodF2
{
public:
    GoodF2()
    {
        cout << "无参构造" << endl;
        pbu = new Building;
    }
    void func()
    {
        cout << "访问:" << pbu->keting << endl;
        cout << "访问:" << pbu->woshi << endl;//通过成员指针访问私有成员
        
    }
    //拷贝构造
    GoodF2(const GoodF2 &f2)
    {
        cout << "拷贝构造" << endl;
        //1.申请空间
        pbu = new Building;
​
    }
    ~GoodF2()
    {
        cout << "析构函数" << endl;
        if (pbu != NULL)
        {
            cout << "pbu" << endl;
            delete pbu;
        }
    }
public:
    Building *pbu;
};
​
void test02()
{
    GoodF2 f;
    f.func();
​
    GoodF2 f2 = f;
​
}

3.类的友元成员函数（难点）

//1.编译器知道类的声明，不知道类的结构
class Building;//声明类
class GoodGay
{
public:
    void func(Building &bud);
};
class Building
{
    //声明GoodGay类的成员函数func成为Building类的友元函数
    friend void GoodGay::func(Building &bud);
public:
    Building()
    {
        keting = "客厅";
        woshi = "卧室";
    }
​
public:
    string keting;
private:
    string woshi;
};
​
​
void GoodGay::func(Building &bud)
{
    cout << "访问:" << bud.keting << endl;
    cout << "访问:" << bud.woshi << endl;
}
​
void test()
{
    Building bud;
    GoodGay GF;
    GF.func(bud);
}

4.友元的注意：

1．友元关系不能被继承。

2．友元关系是单向的，类A是类B的朋友，但类B不一定是类A的朋友。

3.友元关系不具有传递性。类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。

08.单例模式（重点难点）

1.单例模式是一个类只能实例化一个对象

2.实现单例模式的思路

1.把无参构造函数和拷贝构造函数私有化

2.定义一个类内的静态成员指针

3.在类外初始化时，new一个对象

4.把指针的权限设置为私有，然后提供一个静态成员函数让外面获取这个指针

//单例模式是一个类只能实例化一个对象
class Maker
{
    //1.把构造函数私有化
private:
    Maker()
    {
    }
    Maker(const Maker &m)
    {
​
    }
public:
    //静态成员函数，访问静态成员变量
    //4.把指针的权限设置为私有，然后提供一个静态成员函数让外面获取这个指针
    static Maker* getMaker()
    {
        return pMaker;
    }
private:
    //2.定义一个类内的静态成员指针
    static Maker *pMaker;
};
//3.在类外初始化时，new一个对象
Maker *Maker::pMaker = new Maker;//这里可以new是因为在Maker::作用域，编译器把它当成在类内
​
void test()
{
    //Maker m;
    Maker *m = Maker::getMaker();
    Maker *m2 = Maker::getMaker();
    cout << "m=" << m << endl;
    cout << "m2=" << m2 << endl;
​
    //Maker m3 = *m;//调用拷贝构造，这里会产生新对象，所以要把拷贝构造也私有化
    //cout << "m3=" << &m3 << endl;
}

3.单例模式案例（需求：获取打印机打印次数）

//需求，获取打印机使用的次数
class Printer
{
private:
    //1.把无参构造和拷贝构造私有化
    Printer()
    {
        mcount = 0;
    }
    Printer(const Printer &p)
    {
​
    }
public:
    static Printer *getPrinter()
    {
        return p;
    }
​
    void printPrinter(string name)
    {
        cout << name << ":打印" << endl;
        mcount++;
    }
    int getCount()
    {
        return mcount;
    }
private:
    int mcount;//记录打印打印的次数
    //2.定义静态成员指针
    static Printer *p;
};
//3.类外进行初始化，new对象
Printer *Printer::p = new Printer;
​
void test()
{
    //销售部
    Printer *p1 = Printer::getPrinter();
    p1->printPrinter("销售部");
​
    //技术部
    Printer *p2 = Printer::getPrinter();
    p2->printPrinter("技术部");
​
    //公关部
    Printer *p3 = Printer::getPrinter();
    p3->printPrinter("公关部");
​
    Printer *p4 = Printer::getPrinter();
    cout << "打印使用的次数:"<<p4->getCount() << endl;
​
}