1、c++ const 修饰 构造函数

2 拷贝构造函数的调用时机

//等号右边都是对象的时候是拷贝，等号右边是数字是值的时候是构造；
1.一个对象给另外一个对象初始化时
1)Maker m1;
Maker m2=m1;
2)maker m3(m2);

2.实参个形参赋值
Void (maker m)

3.函数返回值
Maker ()
{
Return maker;
}
1）debug下调用拷贝
其他情况下不会调用，只是把return 出来的空间给出来

3构造函数调用的规则（写了构造必须要用）

1自己写了拷贝构造函数，编译器不会提供任何的构造函数
2自己写了有参构造函数，编译器不会提供无参数构造函数，提供拷贝构造函数

4多个对象的构造函数和析构函数的调用顺序

1先调用成员对象的构造函数（析构函数相反）

5深拷贝浅拷贝

浅拷贝：c++编译器只会简单的拷贝，如果在构造函数中出现了开辟空间，指针等操作注意使用深拷贝
深拷贝：拷贝指针指向的那块空间

6匿名对象

1匿名对象的生命周期在本行，对应匿名对象关键是要看接受他的时机

7C++类对象中成员函数和成员变量是分开存储的

1）普通成员变量：存储于对象中，与struct变量有相同的内存布局和字节对齐方式
2）静态成员变量：存储于全局数据区中

8C++编译器对普通成员函数的内部处理

9静态成员函数

//静态成员变量：
//1.属于类，不属于某个对象
//2.静态成员函数统一管理静态成员变量
//3.在内声明，在类外定义（const修饰的除外）
//4.生命周期整个程序，作用域类内
//5.静态成员变量也有权限
//6.访问：普通成员函数，静态成员函数，类

10类的大小（函数和成员分开存储）

为什么空类是1？多个对象在实例化时，编译器好区分那个对象
3、普通成员函数不占类的大小
4、静态成员函数不占类的大小
5、静态成员变量不占类的大小
6、类的大小是普通成员变量决定
对象的大小也是普通成员变量决定

11常对象和常函数

4常对象
1.常对象不能修改普通成员变量（mutable除外）
2.常对象调用常函数

void test01()
{
    const Maker m;
    cout << m.age << endl;
    //m.age = 1;err      1.常对象不能修改普通成员变量（mutable除外）
    //                 2.常对象调用常函数
    m.pu();
    cout << "------------------------------------" << endl;
}
5常函数
//const 修饰成员函数，该函数就变成常函数
    //const修饰的是指针，不能修改this指针指向的那块空间内容(mutable除外)
    void print_() const
    {
        //age = 1000;
        id = 1000;
        cout << age << endl;
        cout << id<< endl;
    }

全局友元函数（访问私有属性）

在类中。。。 声明的位置没有关系
friend void test01(Maker &obj);//只是声明不是类的成员函数

友元类

若B是A的友元类，则b类的所有成员函数都是a类的友元函数
友元类通常设计为一种 对数据 操作或者类之间传递消息辅助类

/*
1．友元关系不能被继承。
2．友元关系是单向的，类A是类B的朋友，但类B不一定是类A的朋友。
3．友元关系不具有传递性。类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。

*/

class Maker
{
    //声明Student这个类为Maker类的友元类
    friend class Student;
public:
    Maker()
    {
        id = 2;
        age = 20;
    }

    Maker(int id, int age)
    {
        this->id = id;
        this->age = age;
    }

private:
    int id;
    int age;

};

class Student
{
public:
    Student()
    {
        p = new Maker;

    }
    void pirntMaker(Maker &maker)
    {
        cout << maker.id << " " << maker.age << endl;
    }
    void printMaker2()
    {
        cout << p->id << " " << p->age << endl;
    }

    ~Student()
    {
        if (p != NULL)
        {
            delete p;
            p = NULL;
        }
    }

public:
    //通过类内的指针来访问
    Maker *p;

};

类的成员函数作为类友元函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

/*
1．友元关系不能被继承。
2．友元关系是单向的，类A是类B的朋友，但类B不一定是类A的朋友。
3．友元关系不具有传递性。类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。

*/

class Maker
{
    //声明Student这个类为Maker类的友元类
    friend class Student;
public:
    Maker()
    {
        id = 2;
        age = 20;
    }

    Maker(int id, int age)
    {
        this->id = id;
        this->age = age;
    }

private:
    int id;
    int age;

};

class Student
{
public:
    Student()
    {
        p = new Maker;

    }
    void pirntMaker(Maker &maker)
    {
        cout << maker.id << " " << maker.age << endl;
    }
    void printMaker2()
    {
        cout << p->id << " " << p->age << endl;
    }

    ~Student()
    {
        if (p != NULL)
        {
            delete p;
            p = NULL;
        }
    }

public:
    //通过类内的指针来访问
    Maker *p;

};

void test()
{
    Maker m(1, 18);

    Student s;
    s.pirntMaker(m);

    Student s2;
    s2.printMaker2();

    Maker m2;

    m2.func();
}

int main()
{
    test();
    system("pause");
    return EXIT_SUCCESS;
}