类的常量成员

重载= 和构造类似

father s(0);

father s=0;//定义的时候初始化 隐性调用构造函数  定义对象的时候直接赋值

s=1;//调用重载=  定义对象之后 再对对象赋值

1.c++的四个强转

static_cast<类型>值 不需要做任何检查 

const_cast const 引用  const指针 去掉变量边上的const   int *p = const_cast<int*>(&x);

reinterpret_cast 指针和int都是四个字节 所以可以吧地址存放到int里面

dynamic_cast 检查多态的时候  执政/引用转换的安全性

　　　　　　 父类地址 转换子类对象 有安全隐患 最后返回null

父类指针可以指向子类函数 运用虚函数 间接的对子类对象的调用

子类指针至下关父类对象 子类指针访问子类成员 不可访问父类成员 会有越界隐患 所以要用到强转

2.类中成员变量和成员函数的访问方式

　静态编译 编译之前 确定调用什么函数 比较快 但不灵活

　动态编译 编译之前不知道调用什么函数 根据虚函数 对象中的虚表根据虚表去找函数调用 非常灵活 但是速度比较慢

3.智能指针 头文件<memory>  智能的释放内存

4.类中的const和static

const 在类中 修饰参数 参数不能需改   修饰成员变量 通过初始化形参列表赋值  修饰成员变量 在成员函数后面家，表示这个成员函数不可修改，利用this指针寻找需要的值

5.关于运算符重载的成员指针运算符 .*

son.h文件

#pragma once
#include<iostream>
using namespace std;
class father
{
protected:
    int age;
    char name[20];
public:
    father(){}
    //explicit 禁止隐式调用方式
    /*
    father s(1);显示调用
    father s=1;隐式调用    
    */
    father(int x)
    {
        age = x;
        cout << "调用了构造函数" << endl;
    }
    ~father(){
        cout << "调用了析构函数" << endl;
    }
        virtual void fun()
        {
        }

};

class son:public father
{
protected:
    int score;
public:
    son();
    ~son();
    void fun()
    {}
    void fun2()
    {
        score = 1;//子类新加的函数用来修改子类成员
    }
    void fun2()const{
        this->score;
    }
};

类的常量成员.cpp

#include<vector>
#include<memory>//只能指针 会自动调用析构 但只能调用单个
#include"son.h"
template<class T>
void fun(T a, T b)
{

}
template<class T>
class A
{
public:
    A();
    void fun();
};
template<class T>
A<T>::A()
{

}
template<class T>
void A<T>::fun()
{

}
int main()
{
    //son*Q = dynamic_cast<son*>(new father);子类指针传递给父类对象要进行强转
    //cout<<Q<<endl;
    //Q->fun2();
    {
        auto_ptr<father> point(new father);
        //对象通过析构的时候调用
        /*
        可以选择使用这个智能指针 帮忙管理内存  对象生命周期结束的时候 自动回收内存
        只能指针只能管理一个一个对象 因为内部函数只有一个delete
        auto_ptr内部使用的delete 记得只申请一个
        */

    }
    fun<int>(3, 4);//显式调用 指明T的类型
    fun(3, 4);//隐式调用 根据函数参数确定模板函数T的类型
    A<int> a;//如果是模板类 必须指明参数类型
    vector<int> arr;
    arr.push_back(1);
    cout << arr[0] << endl;
    cout << static_cast<int>(3.14) << endl;
    const int x = 10;
    int *p = const_cast<int*>(&x);
    int y = reinterpret_cast<int>(&x);
    cin.get();
    return 0;

    cin.get();
    return 0;
}