学习C++的道路 博主会持续更新的

2018.9.3 今天开始正式上课了  也是好好开始学习C++的日子了 

今天买了两本书  C++项目开发 与 C接口----等我的书回来一定要好好的学习一波

博主用的编译软件是VS2017 -----  地址 ： https://visualstudio.microsoft.com/zh-hans/vs/whatsnew/

今天：学习了利用继承改写组合关系 我把今天写的笔记总结了下来  如下（有写的不对的地方，大家不要见怪 提出来我们共同解决）：

/*
    8:继承使用的两种情况
    （1）、类之间有自然的继承关系，一个类另一个类的特例。
        fx:一个学生是一个人
    （2）、实现代码复用，一个类需要使用另一个类中的成员时
    9:继承的好处
    （1）、代码复用 code reuse
    （2）、使代码容易修改
    10:两个类之间的交互关系
    （1）、组合类    ------》 一个类中有另一个类的对象 has-a的关系   
        ======  组合改继承 那么 我们可以一步一步去拆分进而去得到
    （2）、继承      ------》 一个雷是另一个类的特例 is-a的关系

    学到了学到了  输出运算符重载
    ostream & operator << (ostream & os, Point & apoint){
        os << "Point:X:Y: "<<apoint.x<<","<<apoint.y<<"
";
        return os;
        //其中   Point是具体的某一个类  这个类名是可以进行更改的
    }

*/
#include <iostream>
using namespace std;
class Point {

};

class Circle {
private:
    Point center;
    float radius;
};

class Cylinder {
private:
    Circle c;
    float height;
};

//上边是用组合来写的
//接下来给出用继承来写
class Point1{
private:
    float x, y;
};

class Circle1:Point1 {
private:
    float radious;
};

class Cylinder : Circle1 {
private:
    float height;  //自己扩展 + 父类的成员 + 爷爷的成员
};

//接下来书写组合改继承的具体代码  注意：与上边要分开 否则一起运行时会报错的

#include <iostream>
#include <cmath>
using namespace std;

class Point {
    friend ostream & operator << (ostream & , Point & );
protected:
    double x, y;
public:
    Point():x(0),y(0){}
    Point(double _x, double _y) {
        x = _x;
        y = _y;
    }
};

ostream & operator << (ostream & os, Point & apoint) {
    os << "Point:X:Y " << apoint.x << "." << apoint.y << "
";
    return os;
}

//圆继承点
class Circle : public Point{
    friend ostream & operator << (ostream &, Circle &);
protected:
    double radius;
public:
    Circle():Point(),radius(0){}
    Circle(double r,double xval,double yval):Point(xval,yval),radius(r){}
     
    double area() {
        return (3.14159 * radius * radius);
    }
};

ostream & operator << (ostream & os, Circle & aCircle) {
    os << "Cicle:radius:" << aCircle.radius;
    os << aCircle.x << "
";
    os << aCircle.y << "
";
    return os;
}

class Cylinder :public Circle {
    friend ostream & operator << (ostream &, Cylinder &);
protected:
    double height;
public:
    Cylinder() :Circle() { height = 0.0; }
    Cylinder(double hv, double rv, double xv, double yv) :Circle(rv, xv, yv) {
        height = hv;
    }

    double area() {
        return (2 * Circle::area() + 2 * 3.14159 * radius * height);
    }
};

ostream & operator << (ostream & os, Cylinder & acylinder) {
    os << "cylinder dimensions";
    os << "x:" << acylinder.x;
    os << " y:" << acylinder.y;
    os << " radius: " << acylinder.radius;
    os << " height: " << acylinder.height << endl;
    return os;
}

int main(int argc, const char * argv[]) {
    Point p(2, 3);
    Circle c(7, 6, 5);
    Cylinder cyl(10, 11, 12, 13);  //半径不同  调用的函数变量的值不同

    cout << p;
    cout << c;
    cout << "area circle:" << c.area() << endl;

    cout << cyl;
    cout << "area cylinder:" << cyl.area() << endl;

    cout << "area cylinder base is " << cyl.Circle::area() << endl;

    return 0;
}

很开心今天书回来了  好好学习

//今天学习到很过干货

1、子类的析构函数会自动会调用父类的析构函数

2、析构函数是存储保存在栈中的  所以在输出析构函数的时候是有一定的顺序的

3、虚函数----》这是个重点

　　（1）、在使用虚函数之后可以不去使用向下转型

　　（2）、期望父类指针。不管指向父类还是子类，在调用override函数是，反映真实情况

　　（3）、指针或者引用所指向的对象的类型来确定

4、多态-----个人理解（多种形态） 

　　　　fx：　

　　　　　　//Base *p = &d1; //其实与多态类似 主类的指针在不断的变化
　　　　　　//p = &d2; //虚函数的时候只需要改指向就ok
　　　　　　//p = &b; //指哪一个调用哪一个

今天的代码：

//虚函数与多态
/*
    虚函数的使用（根据父类的引用的指向来选择进行哪一个实现）
    虚函数的作用：
        （1）、无需向下转型，就可以正确的用父类的指针或引用
        （2）、期望父类指针。不管指向父类还是子类，在调用override函数是，反映真实情况
        （3）、指针或者引用所指向的对象的类型来确定
*/
#include <iostream>
using namespace std;

class  Base {
public:
    virtual void func() {
        cout << "Base function" << endl;
    }
};

class Derived1 :public Base {
public:
    void func() {
        cout << "Derived1 function" << endl;
    }
};

class Derived2 :public Base {
public:
    void func() {
        cout << "Derived2 function" << endl;
    }
};

void foo(Base & b) {
    b.func();
}

int main() {
    //虚函数（一）
    /*
    Base b;
    Derived1 d;
    Base *p = &d; //父类指针指向子类对象
    Base & br = d; //父类引用指向子类对象
    b.func();    //父类版本
    d.func(); //子类版本
    p->func(); //父类
    br.func();
    foo(b);
    */


    //虚函数（二）
    Base b;
    Derived1 d1;
    Derived2 d2;

    //Base *p = &d1;   //其实与多态类似   主类的指针在不断的变化  
    //p = &d2;   //虚函数的时候只需要改指向就ok
    //p = &b;  //指哪一个调用哪一个
    //p->func();   


    Base *p[3] = { &b,&d1,&d2 };  //父类指针数组   -------->   厉害 厉害 学到了  学到了
    for (int i = 0; i < 3; ++i)
    {
        p[i]->func();
    }
    return 0;
}

//加强虚函数的使用
#include <iostream>
using namespace std;

class Thing {
public:
    virtual void what_Am_I() {
        cout << "I am a Thing.
";
    }
    ~Thing() {
        cout << "Thing destructor" << endl;
    }
};

class Animal : public Thing {
public:
    virtual void what_Am_I() {
        cout << "I am a Animal.
";
    }

    //子类析构函数会自动调用父类的析构函数
    //注意析构函数的存储是保存在栈中的  所以这边输出的时候是有一定的顺序的
    ~Animal() {
        cout << "Animal destructor" << endl;  
    }
};

int main() {
    Thing t;
    Animal x;
    Thing* array[2]; //声明一个父类指针数组
    array[0] = &t;
    array[1] = &x;
    for (int i = 0; i < 2; i++) {
        array[i]->what_Am_I();
    }
    return 0;
}

2018.9.5（上午10点  看了关于本地时间的一些函数）

http://www.runoob.com/cplusplus/cpp-date-time.html

一些代码

#include <iostream>
#include <bits/stdc++.h>
#include <ctime>

using namespace std;

/*
    当地时间的结构体  用于ctime头文件中
    struct tm {
        int tm_sec;   // 秒，正常范围从 0 到 59，但允许至 61
        int tm_min;   // 分，范围从 0 到 59
        int tm_hour;  // 小时，范围从 0 到 23
        int tm_mday;  // 一月中的第几天，范围从 1 到 31
        int tm_mon;   // 月，范围从 0 到 11
        int tm_year;  // 自 1900 年起的年数
        int tm_wday;  // 一周中的第几天，范围从 0 到 6，从星期日算起
        int tm_yday;  // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起
        int tm_isdst; // 夏令时
    } 
*/

int main(int argc, char const *argv[])
{
    //基于当前系统的当前日期
    time_t now = time(0);

    //把 now转换成字符串形式
    char* dt = ctime(&now);

    cout<<"本地日期和时间： "<<dt<<endl;

    //把now转换成为tm结构
    tm * gmtm = gmtime(&now);
    dt = asctime(gmtm);
    cout<<"UTC日期和时间: "<<dt<<endl;
    
    cout<<"1970 到目前经过的秒数：    "<<now<<endl;
    
    tm * ltm = localtime(&now);
    
    //输出tm结构的各个组成部分
    cout<<"年：    "<<1900 + ltm->tm_year<<endl; 
    cout<<"月    "<<1 + ltm->tm_mon<<endl;
    cout<<"日    "<<ltm->tm_mday<<endl;
    cout<<"时间：    "<<ltm->tm_hour<<endl;
    cout<<ltm->tm_min<<":";
    cout<<ltm->tm_sec<<endl;
    return 0;
}

2018.9.5(下午)

　　今天在学习虚函数的基础上，学习了虚析构函数。

　　在今天的学习中了解到，如果一个类是父类 那么它的析构函数就必须是虚函数

　　如果不是虚析构函数的话就会造成内存泄漏，会引起报错。（在C++学习中一定需要注意）

#include <iostream>
using namespace std;

class Base {
public:
    Base(){}
    virtual ~Base() {
        cout << "Base destructor!" << endl;
    }
};

class Derived : public Base {
public:
    Derived(){}
    ~Derived() {
        cout << "Derived destructor!" << endl;
    }
};

int main() {
    Base p1; //存在于栈区
    Base* p2  = new Base(); //存在于堆区
    Base *p = new Derived(); //声明一个子类对象在堆空间

    //当把父类的虚构函数变为虚函数是  释放得劲就是子类的成员
    delete p; //调用父类的析构函数，子类只释放了继承自父类的成员  内存泄漏
    return 0;
}

2018.9.10(前几天有事情，没有更新)

1、纯虚函数：虚函数只有声明，函数体=0；就是一个纯虚函数
2、拥有纯虚函数的类叫做抽象类，抽象类只能作为基类，不能实例化对象
3、抽象类提供不同种类的之类对象的一个接口
4、纯虚函数被定义在派生类中。如果派生类不重写基类的纯虚函数，则派生类也是一个抽象类

/*
    抽象基类与纯虚函数
*/

#include <iostream>
#include <math.h>
using namespace std;

class Point
{
private:
    double x;
    double y;
public:
    Point(double i, double j) :x(i), y(j) {}

    void print() const
    {
        cout << "(" << x << "," << y << ")" << endl;
    }
};

class Figure
{
private:
    Point center;
public:
    Figure(double i = 0, double j = 0) :center(i, j) {}

    Point& location()
    {
        return center;
    }

    void move(Point p)
    {
        center = p;    //改变图形的中心点
        draw();        //调用draw对图形重新绘制
    }
    //纯虚函数 虚函数只有声明，没有实现，函数体 = 0
    virtual void draw() = 0;
    virtual void rotate(double) = 0;    // 旋转图形 也没有实现
};
    class Circle :public Figure
    {
    private:
        double radius;
    public:
        Circle(double i = 0, double j = 0, double r = 0):Figure(i,j),radius(r){}
        void draw()  //对父类的Figure中的纯虚函数进行实现
        {
            cout << "A circle with center" << endl;
            Figure::location().print();
        }
    };

2018,.9.11(今天学习了多继承)

1、第一种

#include <iostream>
using namespace std;

class A
{
private:
    int i;
public:
    A(int i):i(i){}
    void print()
    {
        cout << i << endl;
    }
};

class B
{
private:
    int j;
public:
    B(int j) :j(j) {}
    void print()
    {
        cout << j << endl;
    }
};

class C :public A, B
{
private:
    int k;
public:
    C(int i,int j,int k):A(i),B(j),k(k){}
    void get_Message()
    {
        A::print();
        B::print();
    }
};

int main()
{
    C x(5, 8, 10);
    x.get_Message();


    //x.print();   会报错  因为它不知道去调用哪一个父类的print函数

    //针对上一个问题的方法 在子类调用print函数时加上某个父类的作用域函数
    x.A::print();
    return 0;
}

2、第二种（菱形继承）

 下边代码分两种情况  （1）、一个错误情况　　（2）、正确情况

//2、菱形继承（有共同祖先） 二义性  代码解释 
#include <iostream>
using namespace std;

class R    //祖先类
{
private:
    int r;
public:
    R(int anInt) { r = anInt; }
    void printOn() const { cout << "r=" << r << endl; }
};

//父类A
class A : public R
{
    int a; //父类A会有一份r
public:
    A(int int1, int int2) :R(int2) { a = int1; }
};

//父类B
class B : public R
{
    int b;    //父类B会有一份r
public:
    B(int int1, int int2) :R(int2) { b = int1; }
};

//孙子辈的子类继承父类A和B
class C :public A, public B
{
    int c; //子类会有两份r，一份来自A,一份来自B
public:
    C(int int1, int int2, int int3) :A(int2, int3), B(int2, int3) { c = int1; }

};

int main()
{
    R rr(10);
    A aa(20, 30);
    B bb(40, 50);
    C cc(5, 7, 9);
    rr.printOn();
    aa.printOn();
    bb.printOn();
    cc.printOn(); //error   vs直接报错  不明确
    return 0;
}

/*
    为了解决二义性 我们需要使用虚继承
    虚继承
        1、直接继承祖先的两个基类，在继承是加virtual
        2、通过多重继承而来的那个子类，在构造函数时，要调用祖先类的
           构造函数。
*/

include <iostream>
using namespace std;

class R    //祖先类
{
private:
    int r;
public:
    R(int anInt) { r = anInt; }
    void printOn() const { cout << "r=" << r << endl; }
};

//父类A  虚继承
class A :virtual public R
{
    int a; //父类A会有一份r
public:
    A(int int1, int int2) :R(int2) { a = int1; }
};

//父类B  虚继承
class B :virtual public R
{
    int b;    //父类B会有一份r
public:
    B(int int1, int int2) :R(int2) { b = int1; }
};

//孙子辈的子类继承父类A和B
class C :public A, public B
{
    int c; //子类直接继承祖先类R的成员，再继承两个父类各自扩张的成员
public:
    C(int int1, int int2, int int3 ,int int4) :R(int1),A(int2, int1), B(int2, int1) { c = int4; }

};

int main()
{
    R rr(10);
    A aa(20, 30);
    B bb(40, 50);
    C cc(5, 7, 9,10);
    rr.printOn();
    aa.printOn();
    bb.printOn();
    cc.printOn(); 
    /*
        因为虚继承C中的r和printOn函数直接从R类中继承，所以孙子类中
        只会有一份R的成员，不会重复继承
    */
    return 0;
}