//c风格的字符串
char str[]="helloworld";
//c++风格的字符串
//要包含头文件
string str="helloworld";

//整形
int a =0;
cout << "请输入整形变量:" << endl;
cin >> a;
cout << a << endl;

//浮点型
double a =0;
cout << "请输入浮点型变量:" << endl;
cin >> a;
cout << a << endl;

//字符型
char a =0;
cout << "请输入字符型变量:" << endl;
cin >> a;
cout << a << endl;

//字符串型
string a =0;
cout << "请输入字符串型变量:" << endl;
cin >> a;
cout << a << endl;

int *a=new int(10);

int &ref2=test02();

test02()=1000;

void func(int &ref)
{
    ref=100;
}

int main()
{
int a=10;
    //自动转换为int *const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可以改
    int &ref=a;
    ref=20;
    
    func(a);
    return 0;
}

int func(int a,int b=10,int c=10)
{
return a+b+c;
}
//1.如果某个位置参数有默认值，那么这个位置往后，从左向右，必须都要有默认值
//2.如果函数声明有默认值，函数实现的时候就不能有默认值

const double PI =3.14;
class Circle 
{
    //访问权限
public:
    //圆的属性
    int m_r;
    //行为
    //获取周长
    double calculateZC()
    {
        return 2*PI*m_r;
}
}

int main()
{
//通过圆类 创建具体的圆（对象）
    //实例化(通过一个类  创建一个对象的过程) 
    Circle c1;
    //给圆对像的属性进行赋值、
    c1.m_r=10 ;
    cout << c1.calculateZC()<<endl;
    return 0;
}

class Student//设计学生类
{
    public ://公共权限
    //类中的属性和行为  我们统称为 成员
    //属性 也成为 成员属性 成员变量
    //行为 也称为 成员函数 成员方法
    //属性 
    string m_Name;
    int m_Id;
    //行为
    void show()
    {
        cout<<"姓名：  " << m_Name << "学号 :" << m_Id<<endl;
    }
    void set_name(string name)
    {
        m_Name=name;
}
    void set_Id(int id)
    {
        m_Id=id;
    }
}

int main()
{
    Student s1;
    cin>>s1.m_Name>>m_Id;
    s1.show();
    Student s1;
    s2.set_name("张三");
    s2.set_Id(1);
    return 0;
}

//访问权限 三种
//公共权限public成员 类内可以访问 类外也可以访问
//保护权限protected成员 类内可以访问 类外不可以访问
//私有权限private成员 类内可以访问 类外不可以访问
//私有权限与保护权限的区别 在继承的时候可以区分 儿子可以访问父亲中的保护内容
//儿子不可以访问父亲的私有内容
class Person
{
public:
string m_Name;
protected:
    string m_Car;
private:
    int m_Password;
public:
    void func()
    {
        m_Name="张三";
        m_Car="饿狼传说"；
        m_Password=123145;
}
};

class Point
{
    public:
    //在此实现成员函数
    private:
    int m_X;
    int m_Y;
}
class circle
{
    public:
    //在此实现成员函数
    private:
    int m_R;
    Point m_Center;
}

//在头文件中可以进行类的声明
class Point
{
    public:
    void setx(int x);
    void sety(int y);
    private:
    int m_X;
    int m_Y;
}

class Circle
{
    public:
    void setm_R(int r);
    int getr();
    private:
    int m_R;
    Point Center;
}
//在其余的文件定义该函数的时候需要加作用域
void Point:: setx(int x)
{
    m_X=x;
}

class Person
{
    public:
    Person()
    {
        cout << "Person" << endl;
    }
    Person(int a,int height)
    {
        m_age =a;
        m_height= new int(height);
    }
    Person(const Person &other)
    {
        cout << "Personkb" << endl;
        m_age = other.m_age;
        m_height =new int(*other.m_height);//深拷贝
    }
    ~Person()
    {
        //析构，将堆区开辟的空间做释放操作
        if(m_height !=NULL)
        {
            delete m_height;
        }
        cout << "Personxg" << endl;
    }
    int m_age;
    int *m_height; 
};

void test01()
{
    Person p1(18,160);
    cout << p1.m_age << endl;
    cout << *p1.m_height << endl;
    Person p2(p1);
    cout << p2.m_age << endl;
    cout << *p2.m_height <<endl;//会发生错误，因为p2是浅拷贝，但析构函数内部对p2进行了释放
}

int main()
{
    test01();
    return 0;
}

class Person
{
public:
    //Person(int a,int b,int c)
    //{
    //m_A=a;m_B=b;m_C=c;
//}
    Person(int a,int b,int c):m_A(a),m_B(b),m_C(c)
    {
        
    }
    int m_A;
    int m_B;
    int m_C;
}
void test
{
    Person p;
}

int main()
{
    test();
    return 0;
}

class A{}
class B
{
    A a;
}//B类中有对象A作为成员，A为对象成员

class Person
{
Public:
    static int m_A;
}

int Person:: m_A=100;

void test()
{
Person P;
    cout << P.m_A <<endl;//100
    Person p2;
    p2.m_A=200;
    cout << P.m_A <<endl;//200
}

void test02()
{
    cout <<Person :: m_A <<endl;
}

class Person
{
public:
    static void func()
    {
        cout << "static" << endl; 
    }
};

void test()
{
   Person ::func();
}

int main()
{
    test();
    return 0;
}

class Person
{
public:
    Person(int age)
    {
        //解决名称冲突
        this->age = age;
    }
    Person& PersonAddage(Person &P)//要返回引用， 如果返回的是Person的值话，返回的是对p2的一份拷贝
    {
        this->age += P.age;
        return *this;//返回*this
    }
    int age;
};

void test01()
{
    Person p1(18);
    cout << p1.age << endl;
}

void test02()//链式编程思想
{
    Person p1(10);
    Person p2(10);
    p2.PersonAddage(p1).PersonAddage(p1).PersonAddage(p1);
    cout << p2.age <<endl;
}

int main()
{
    test02();
    return 0;
}

class Person
{
public:
    void showClassName()
    {
        cout << "Person" << endl;
    }
    void showPersonAge()
    {
        //报错原因是因为传入的指针是为NULL空的
        if(this==NULL) return;
        cout << "age=" << m_Age << endl;
    }
    int m_Age;
};

void test01()
{
    Person *P=NULL; 
    P->showClassName();
    // P->showPersonAge();
}

int main()
{
    test01();
    return 0;
}

//this指针的本质 是指针常量  指针的指向是不可以修改的
//const Person *const this
void showPerson()const
{
this->m_A =100;
}

Person p3=p1.operator+(p2);
简化为
Person p3=p1+p2;
class Person
{
public:
    // Person operator+(Person &p)
    // {
    //     Person temp;
    //     temp.m_A=this->m_A+p.m_A;
    //     temp.m_B=this->m_B+p.m_B;
    //     return temp;
    // }
    //本质上的调用是 Person p3=p1.operator+(p2);
    int m_A;
    int m_B;
};

Person operator+(Person &p1,Person &p2)//本质上调用是Person p3=operator+(p2,p1);
{
    Person temp;
    temp.m_A=p1.m_A+p2.m_A;
    temp.m_B=p1.m_B+p2.m_B;
    return temp;
}

void test()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    Person p2;
    p2.m_A = 10;
    p2.m_B = 10;
    Person p3=p1+p2;
    cout << p3.m_A << endl;
    cout << p3.m_B << endl;
}

class Person
{
public:
    // 通常不会利用成员函数重载<<运算符，因为无法实现cout在左侧
    // void operator<<()
    // {
    // }
    int m_A;
    int m_B;
};

//只能全局函数来重载左移运算符
ostream& operator<<(ostream &cout,Person &p)
{  
    cout << "m_A=" << p.m_A <<endl;
    cout << "m_B=" << p.m_B <<endl;
    return cout;
}

void test()
{
    Person p;
    p.m_A = 10;
    p.m_B = 10;
    cout << p<<endl;
    cout << p.m_A << " " << p.m_B << endl;
}

class MyIntegar
{
    friend ostream& operator<<(ostream& os,  MyIntegar s);
public:
    MyIntegar()
    {
        m_Num = 0;
    }
    //重载前置++运算符
    MyIntegar& operator++()
    {
        m_Num++;
        return *this;
    }
    MyIntegar operator++(int)//int代表占位参数，可以用于区分前置和后置递增
    {
        MyIntegar temp=*this;
        this->m_Num++;
        return temp;
    }
private:
    int m_Num;
};

ostream& operator<<(ostream& os,  MyIntegar s)
{
    os << s.m_Num ;
    return os;
}

void test()
{
    MyIntegar myint;
    cout << ++(++myint)<<endl; 
    cout << myint << endl;
}

void test2()
{
    MyIntegar myint;
    cout << myint++<<endl; 
    cout << myint << endl;
}

class Person
{
public:
    Person(int age)
    {
        m_Age = new int(age);
    }
    Person& operator=(Person &p)
    {
        //应该先判断是否有属性在堆区，如果有先释放干净，然后在深拷贝
        if(m_Age !=NULL)
        {
            delete m_Age;
        }
        m_Age= new int(*(p.m_Age));
        return *this;
    }
    ~Person()
    {
        if(m_Age!=NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
    }
    int *m_Age;
};

void test()
{
    Person p1(18);
    Person p2(20);
    Person p3(30);
    p3=p2=p1;
    cout << *p1.m_Age << endl;
    cout << *p2.m_Age << endl;
    cout << *p3.m_Age << endl;
}   

class Person
{
public:
    Person(string name,int age)
    {
        m_Name=name;
        m_Age=age;
    }
    bool operator==(Person &P)
    {
        if(this->m_Name==P.m_Name && this->m_Age==P.m_Age)
        {
            return true;
        }
        return false;
    } 
     bool operator!=(Person &P)
    {
        if(this->m_Name==P.m_Name && this->m_Age==P.m_Age)
        {
            return false;
        }
        return true;
    } 
    string m_Name;
    int m_Age;
};

void test()
{
    Person p1("John",18);
    Person p2("John",18);
    if(p1 == p2)
    {
        cout << "p1==p2" << endl;
    }
    else
    {
        cout << "p1!=p2" << endl;
    }
}

class Myprint
{
public:
    //重载函数调用运算符
    void operator()(string test)
    {
        cout << test << endl;
    }
};

void test()
{
    Myprint Myprint;
    Myprint("helloworld");
}

void test02()
{
MyAdd myadd;
    int ret=myadd(100,100);
    cout << ret << endl;
    
    //匿名函数对象
    cout << MyAdd()(100,100)<< endl;
}

class BasePage
{
public:
    void header()
    {
        cout << "首页、公开课、登陆、注册（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图、（公共底部）" << endl;
    }
    void left()
    {
            cout << "公共分类列表" << endl;
    }
};

class Java: public BasePage
{
public:
    void content()
    {
        cout << "java" << endl;
    }
};

class Python : public BasePage
{
public:
    void content()
    {
        cout << "phthon" << endl;
    }
};

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son :public Base
{
public:
    int m_D;
};

int main()
{
    cout << sizeof(Son) << endl; //**16**
    return 0;
}

class Base
{
    public:
    Base()
    {
        cout << "Base" << endl;
    }
    ~Base()
    {
        cout << "Basexg" << endl;
    }
};

class Son :public Base
{
    public:
    Son()
    {
        cout << "Son" << endl;
    }
    ~Son()
    {
        cout << "Sonxg" << endl;
    }
};

void test()
{
    Son s;
}

int main()
{
    test();
    return 0;
}

void test()
{
    Son s;
    cout << s.m_A << endl;
    cout << s.Base::m_A << endl;//如果通过子类对象  访问到父类中同名成员，需要加作用域
}

//同名函数的处理方式
void test01()
{
    Son s;
    s.func();
    s.Base::func();
}

//同名静态成员属性
void test()
{
    //通过对象访问
   Son s;
    cout << s.m_A << endl; 
    cout << Son:: m_A << endl;
    cout << Base ::m_A << endl;
    //通过对象访问
    cout << s.Base::m_A << endl;
    //第一个冒号 代表通过类名方式访问  第二个冒号代表父类作用域下
    cout << Son::Base::m_A << endl; 
}

//同名静态成员函数
void test01()
{
    //通过对象访问
    Son s;
    s.func();
    s.Base::func();
    //通过类名访问
    Son ::func();
    Son::Base::func();
}

class Son :public Base1,public Base2

class Animal
{
public:
    int m_Age;
};
//利用虚继承  解决菱形继承问题
//继承之前加上virtual 变为虚继承
//Animal类称为 虚基类
//羊类
class Sheep : virtual public Animal{};
class Tuo : virtual public Animal{};
class SheepTuo :public Sheep,public Tuo{};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 18;
    st.Tuo::m_Age = 28;
    cout << st.Sheep::m_Age << endl;
    cout << st.Tuo::m_Age << endl;
    cout << st.m_Age << endl;
}

class Animal
{
public:
    //虚函数
    virtual void spaek()
    {
        cout << "speak Animal" << endl;
    }
};

class Cat :public Animal
{
public:
    void speak()
    {
        cout << "speak Cat" << endl;
    }
};
//如果想执行对应的子类函数，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，晚绑定
void dospeak(Animal &A)
{
    A.spaek();
}

void test()
{
    Cat cat;
    dospeak(cat);
}

class Animal
{
public:
virtual void speak()
    {
cout << "Animal Speak" << endl;
    }
};

void test()
{
    cout << sizeof(Animal) << endl;//8   这是一个指针的大小，当使用虚函数的时候，内部生成
       //一个vfptr的指针，指向函数的所在位置
}

class Base
{
public:
    //纯虚函数
    //只要有一个纯虚函数，这个类称为抽象类
    //特点：无法实例化对象      抽象类的子类  必须要重写父类中的纯虚函数，否则也属于抽象类
    virtual void func() = 0 ;
};

class Son : public Base
{
public:
    virtual void func()
    {
        cout << "实现函数" << endl;
    }
};

void test()
{
    //Base b;
    //new Base;无法实例化对象
    Son s;//子类必须重写纯虚函数
    s.func();
}

class AbstractDrinking
{
public:
    virtual void Bool( ) = 0;
    virtual void Brew( ) = 0;
    virtual void PourInCup( ) = 0;
    virtual void PutSomething( ) = 0;
    void makeDrinking()
    {
        Bool( );
        Brew( );
        PourInCup();
        PutSomething( );
    }
};

class coffee :public AbstractDrinking
{
    virtual void Bool( ) 
    {
        cout << "Coffeewater" << endl;
    }
    virtual void Brew( ) 
    {
        cout << "冲泡咖啡" <<endl;
    }
    virtual void PourInCup( ) 
    {
        cout << "倒入杯中" << endl;
    }
    virtual void PutSomething( )
    {
        cout << "Put something" << endl;
    }
};

class Tea :public AbstractDrinking
{
    virtual void Bool( ) 
    {
        cout << "Teawater" << endl;
    }
    virtual void Brew( ) 
    {
        cout << "茶叶咖啡" <<endl;
    }
    virtual void PourInCup( ) 
    {
        cout << "倒入杯中" << endl;
    }
    virtual void PutSomething( )
    {
        cout << "Put something" << endl;
    }
};

class Animal
{
public:
    Animal()
    {
        cout << "Animal的构造函数" << endl;
    }
    // virtual ~Animal() //利用虚析构可以解决 父类指针释放子类对象时的不干净的问题
    // {
    //     cout << "Animal的析构函数" << endl;
    // }
    //需要声明 ，也需要实现
    virtual ~Animal () = 0;
    virtual void speak()=0;
};

Animal :: ~Animal()
{
    cout << "Animal的纯虚析构" << endl;
}

class Cat : public Animal
{
public:
    Cat(string name)
    {
        cout << "cat的构造函数" << endl;
        m_Name = new string(name);
    }
    virtual void speak()
    {
        cout << *m_Name << "Cat Speaking" << endl;
    }
    ~Cat()
    {
        if(m_Name!=NULL)
        {
            cout << "cat的析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        } 
    }
    string *m_Name;
};

void test01()
{
    Animal *a = new Cat("Tom");
    a->speak();
    //父类指针在析构的时候 ，不会调用子类中的析构函数 ，导致子类如果有属性在堆区的话 ，出现了内存泄漏
    delete a;
}

//虚析构语法：
virtual ~类名(){}
//纯虚析构语法：
virtual ~类名() = 0;
类民::~类名(){}

class CPU
{
public:
    virtual void calculate() = 0;
};

class VideoCard 
{
public:
    virtual void display() = 0;
};

class Memory
{
public:
    virtual void storage() = 0;
};

class Computer
{
public:
    Computer(CPU *cpu,VideoCard *vc ,Memory *mem)
    {
        m_mem = mem;
        m_vc = vc;
        m_cpu=cpu;     
    }
    void work()
    {
        m_cpu->calculate();
        m_vc->display();
        m_mem->storage();
    }
    ~Computer() 
    {
        if( m_cpu!= NULL)
        {
            delete m_cpu;
            m_cpu=NULL;
        }
        if(m_mem!=NULL)
        {
            delete m_mem;
            m_mem=NULL;
        }
        if(m_vc!=NULL)
        {
            delete m_vc;
            m_vc=NULL;
        }
    }
private:
    CPU * m_cpu;
    VideoCard *m_vc;
    Memory *m_mem;
};


class Intelcpu:public CPU
{
    virtual void calculate() 
    {
        cout << "Intel CPU Start" << endl;
    }
};

class IntelVideocard:public VideoCard
{
    virtual void display() 
    {
        cout << "Intel Videocard Start" << endl;
    }
};

class IntelMemory:public Memory
{
    virtual void storage() 
    {
        cout << "Intel Memory Start" << endl;
    }
};

class Lenovocpu:public CPU
{
    virtual void calculate() 
    {
        cout << "Lenovo CPU Start" << endl;
    }
};

class LenovoVideocard:public VideoCard
{
    virtual void display() 
    {
        cout << "Lenovo Videocard Start" << endl;
    }
};

class LenovoMemory:public Memory
{
    virtual void storage() 
    {
        cout << "Lenovo Memory Start" << endl;
    }
};

void test()
{
    CPU * intelcpu=new Intelcpu;
    VideoCard * intelvideocard=new IntelVideocard;
    Memory * intelmemory=new IntelMemory;
    Computer * first= new Computer(intelcpu,intelvideocard,intelmemory);
    first->work();
    delete first;
    cout << "-----------------------" << endl;
    Computer * second= new Computer(new Lenovocpu,new LenovoVideocard,new LenovoMemory);
    second->work();
    delete second;
}

int main()
{
    test();
    return 0;
}