学习笔记(13):c++入门到精通教程 c++11/14/17-inline、const、mutable、this、static

立即学习:https://edu.csdn.net/course/play/9186/191697?utm_source=blogtoedu

#include <iostream>
#include "Time.h"

using namespace std;

//class student {
//
//public:
//    int number;
//    char name;
//};

//class Time2
//{
//public:
//    int Hour;
//    int Minute;
//    int Second;
//
//    void initTimes( int tmphours, int tmpmins, int tmpsecs)
//    {
//         Hour = tmphours;
//         Minute = tmpmins;
//         Second = tmpsecs;
//
//    }
//
//};
//class Time
//{
//public:
//    int Hour; //小时
//    int Minute;//分钟
//    int Second;//秒钟
//
//    void initTime( int tmphour, int tmpmin, int tmpsec)
//    {
//         Hour = tmphour;
//         Minute = tmpmin;
//         Second = tmpsec;
//    }
//};
//void ptfunc() const
//{
//    return;
//}
//静态成员变量定义（分配内存）
int Time::mystatic = 15; //可以不给初值，那么系统默认给0；

 
 int main()
{
    
    //student someone; //定义一个类对象
    //someone.number = 1000;
    //student* psomeone = &someone;
    //psomeone->number = 1005;        //指针名-> 成员名
    //
    //
    //cout << someone.number << endl;

    //Time myTime;        //类对象
    /*initTime(myTime, 11, 14, 5);*/

    //myTime.initTime(11, 14, 5);
    //cout << myTime.Hour << endl;
    //cout << myTime.Minute << endl;
    //cout << myTime.Second << endl;

    //Time2 myTime;
    //myTime.initTimes(11, 14, 5);
    initTimes(myTime, 11,14,89);
    //cout << myTime.Hour << endl;
    //cout << myTime.Minute << endl;
    //cout << myTime.Second << endl;

    //Time myTime;
    //myTime.Hour = 12;
    //myTime.Minute = 15;
    //myTime.Second = 40;

    //Time myTime2 = myTime;
    //Time myTime3(myTime);
    //Time myTime4{myTime};
    //Time myTime5 = {myTime};
    //myTime5.Hour = 8;

    //一： 构造函数: 在类中有一种特殊的成员函数，它的名字和类名相同，我们在创建的对象的时候
    // 这个特殊的成员函数就会被系统自动调用，这个成员函数，就叫“构造函数”;
    //因为构造函数会被系统自动调用，所以我们可以简单的理解为：构造函数的目的就是初始化类对象的数据成员

    //构造函数没有返回值；这是构造函数特殊之处
    //不可以手工调用 构造函数 否则编译就会出错
    //正常情况下，构造函数应该被声明为public，因为我们创建一个对象时系统 要替我们调用构造函数，这说明构造函数是一个public函数
    //因为类缺省的成员是私有成员，所以我们必须说明构造函数是一个public函数，否则就无法直接创建

 //    Time myTime = Time(12, 13, 15); //创建类对象

    //Time myTime2(12,15,52);
    //Time myTime3 = Time{ 12,13,52 };
    //Time myTime4{ 12, 13 ,52 };
    //Time myTime5 = { 12,13,52 };

//    Time myTime();
    //二 ： 多个构造函数：一个类中可以有多个构造函数,就可以为类对象的创建提供多种初始化方法
    //Time myTime = Time();
    //Time myTime12;
    //Time myTime13 = Time{};
    //Time myTime14{};
    //Time myTime15 = {};

    对象拷贝
    //Time myTime20; //可以有直接调用构造函数
    如下四个对象并没有调用传统意义上的构造函数， 实际上他们调用的是“拷贝构造函数”，不是传统意义上的构造函数；
    //Time myTime22 = myTime20;
    //Time myTime23(myTime20);
    //Time myTime24{ myTime20 };
    //Time myTime25 = { myTime20 };

    //函数默认参数
    //规定：
    //默认值只能放在函数定义中，除非该函数没有函数声明
    //在具有多个参数的
    /*Time myTime30 = Time{12,13};
    Time myTime32 = Time(12, 13);
    Time myTime33(12,13);
    Time myTime34{ 12,13 };
    Time myTime35 = {12,13 };*/
    
    //四： 隐式转换和explicit
    编译系统，在私下干了我们不了解的事
    //Time myTime40 = 14;            //编译系统肯定有个行为，把14这个数字，转换成了
    //Time myTime41 = (12,13,14,15);
    //func1(11);
    //
    // Time myTime100 = Time{ 16 };
    // Time myTime101 = Time(16);// 含糊不清的写法，就存在临时对象隐式转换；
    // func1(Time(16));//也是含糊不清的写法， 存在临时对象或者隐式转换的问题
    // //是否可以强制系统明确要求构造函数不能做隐式类型转换？ 可以，如果 构造函数中带有explicit，
    // // 则这个构造函数只能用于初始化和显示转换
         Time myTime = Time(12, 13, 15); //创建类对象

    Time myTime2(12,15,52);
    Time myTime3 = Time{ 12,13,52 };
    Time myTime4{ 12, 13 ,52 };
    Time myTime5 = { 12,13,52 };//进行了隐式类型转换。这出问题了赋值列表初始化

    // //对于单参数的构造函数 我们一般声明为explicit 除非你有特别的理由
    // Time time200{};
     Time myTime201 = {};
    // func1(Time{});

//五： 构造函数初始化列表
//专业的素养，专业，高大上
// 效率上要差一些
//Time myTime = Time(12, 13, 52);

//一：
//在类定义中实现成员函数inline：类内的成员函数实现其实也叫类内的成员函数定义
    //这种直接定义中实现的成员函数，会被当做inline内联函数来处理。
 
//二：成员函数末尾的const
//const： 常量：在成员函数屁股后面增加一个const。 不但要在成员函数声明中增加const
//作用： 告诉系统，这个成员函数 不会修改该对象里任何成员变量的值等等，
//屁股后边加一个const后缀 的

    //const Time abc;    //定义const对象，这种对象有限制
    abc.initMilliTime(15500); //不可以，因为initmillitime（）并不是const成员函数，这个initmilliTime只能被非const对象调用
    //Time def;
    def.initMilliTime(1500);
    //def.noone();
    //abc.noone();

    const 成员函数 则不管是const对象， 还是非const ，都可以调用const成员函数。
    //    //

        //三： mutable (不稳定，容易改变的意思) ，const的反义词。 mutable的引入正好是突破const 的限制

        //const Time abc;
        //abc.noone();
        //用mutable修饰一个成员变量，一个成员变量一旦被mutable修饰了，就表示，这个成员永远可以被修改

    //四：返回自身对象的引用， this
//    如何理解这个this，咱们调用成员函数时，编译器负责把这个对象的地址（&mytime）    
//在系统看来 任何

//b） 在普通成员函数中，this是一个指向非const对象的const指针()
//c) 在const成员函数中，this指针是一个指向const对象的const指针（类型为Time）

 

    //Time mytime;
    //mytime.add_hour(3).add_minute(12); //mytime.add_hour(time )

    //五：static成员
//有属于整个类的成员变量，这种成员变量就叫static成员变量
//特点： 不属于某个对象，属于整个类，我们一旦在某个对象中修改了成员变量的值；
// 这种成员变量只有一个副本，对于这种的引用我们
//成员函数前面也可以加static构成， 静态成员函数， 属于整个类的成员函数。 调用时： 类名：：成员函数名{...}
    //如何定义静态成员变量，： 我们会在.cpp 开头来定义这个静态， 这样就能保证初始化
    //Time myTime1;
    //myTime1.Minute = 15;

    //Time myTime2;
    //myTime2.Minute = 20;

    //cout << myTime1.Minute << endl;
    //cout << myTime2.Minute << endl;

cout << Time::mystatic << endl;
    Time myTime1;
    myTime1.mystatic = 40;
    Time myTime2;
    myTime2.mystatic = 80;
    cout << Time::mystatic << endl;
    cout << myTime1.mystatic << endl;
    cout << myTime2.mystatic << endl;

    Time::mstafunc(12);
    myTime1.mstafunc(2);
    myTime2.mstafunc(78);

    cout << Time::mystatic << endl;
    return 0;
}