Time.hpp

//
//  Time.hpp
//  stud
//
//  Created by pt on 2024/4/8.
//

#ifndef Time_hpp
#define Time_hpp
//类声明
#include <iostream>
using namespace std;
class Time
{
private:
    int Millisecond;
    void initMillTime(int mls);//成员函数的声明 -- 配套成员函数的实现
public:
    int Hour;
    int Minute;
    int Second;
    Time(int tmphour, int tmpmin, int tmpsec);//构造函数
    Time();//构造函数
    void initTime(int tmphour, int tmpmin, int tmpsec);//成员函数的声明 -- 配套成员函数的实现
    void show(){std::cout << "hahaha" << std::endl;}//成员函数的定义
};

#endif /* Time_hpp */

Time.cpp

//
//  Time.cpp
//  stud
//
//  Created by pt on 2024/4/8.
//

#include "Time.hpp"
Time::Time(int tmphour, int tmpmin, int tmpsec)//构造函数的实现
{
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;
    
    initMillTime(0);//⬇️
}
Time::Time()//构造函数的实现
{
    Hour = 12;
    Minute = 59;
    Second = 59;
    initMillTime(59);
}
void Time::initMillTime(int mls)//成员函数的实现-- 配套成员函数的声明
{
    Millisecond = mls;//私有成员
}

main.cpp

#include <iostream>
#include "Time.hpp"
using namespace std;
int main()
{
    //Time myTime;//此条语句失效，没有对应的构造器为其初始化
    Time myTime(11, 14, 5);//构造函数初始化
    Time myTimea;//无参构造函数初始化
    
    
    Time(12,13,52);//创建了一个临时的 Time对象，但这个对象并不会绑定到任何变量上，因此它在表达式结束后立即被销毁。这种语句通常用于临时对象的创建，例如在函数调用中传递匿名对象。
    //如果你想在 main 函数中创建一个 Time 对象并保持它存在，你需要给这个对象命名，例如：Time myTime(12，13, 15);
    Time{12,13,15};//同理，创建了一个临时对象

    Time myTime1(12, 13, 52);//直接初始化
    Time myTime1a;//直接初始化，无参
    
    Time myTime2{12, 13, 52};//列表初始化 不允许缩窄变换，允许对于聚合类型（如数组、结构体等）提供初始化
    Time myTime2a{};//列表初始化 无参 不允许缩窄变换，允许对于聚合类型（如数组、结构体等）提供初始化
    
    Time myTime3 = Time(12, 13, 52);//在C++98旧标准下可能会创建一个临时对象然后复制给 myTime，但在C++11新标准下，拷贝/移动构造通常会被优化掉，直接在 myTime 的存储位置构造对象。
    Time myTime3a = Time();//调用无参的构造函数，在C++98旧标准下可能会创建一个临时对象然后复制给 myTime，但在C++11新标准下，拷贝/移动构造通常会被优化掉，直接在 myTime 的存储位置构造对象。
    
    Time myTime4 = Time{12, 13, 52};//在C++98旧标准下可能会创建一个临时对象然后复制给 myTime，但在C++11新标准下，拷贝/移动构造通常会被优化掉，直接在 myTime 的存储位置构造对象。
    Time myTime4a = Time{};//调用无参的构造函数，在C++98旧标准下可能会创建一个临时对象然后复制给 myTime，但在C++11新标准下，拷贝/移动构造通常会被优化掉，直接在 myTime 的存储位置构造对象。
    
    Time myTime5 = {12, 13, 52};//用到隐式类型转化，把花括号中的参数进行隐式类型转换，以创建一个 Time 对象，并将其赋值给 myTime5
    Time myTime5a = {};//省略了 无参 Time myTime5a = Time{};
    
    //不允许Time myTime5 = (12, 13, 52);因为这里使用的是圆括号，而且在圆括号中使用了逗号运算符。在 C++ 中，逗号运算符是一个顺序点，它会按照从左到右的顺序计算表达式，然后返回最后一个表达式的结果。因此，(12, 13, 52) 会先计算 12，然后是 13，最后计算 52 并返回 52。这个表达式的结果是 52，而不是一个三元素的列表。因此，编译器会试图使用单个整数 52 来初始化 myTime5 对象，这当然会失败，除非 Time 类定义了一个接受单个整数参数的构造函数。
    //对象的复制 不调用构造函数
    Time myTime6  = myTime;
    Time myTime7(myTime);
    Time myTime8{myTime};
    Time myTime9 = {myTime};


    
    //每个对象都有不同的内存地址
    std::cout << "初始化部分" << std::endl;
    std::cout << &myTime << '\n'<< &myTimea << '\n' << &myTime1 << '\n' << &myTime1a << '\n'<< &myTime2 << '\n' << &myTime2a << '\n'<< &myTime3 << '\n' << &myTime3a << '\n'<< &myTime4 << '\n' << &myTime4a << '\n'<< &myTime5 << '\n' << &myTime5a << '\n' << std::endl;
    std::cout << "复制部分" << std::endl;
    std::cout<< &myTime6 << '\n' << &myTime7 << '\n' << &myTime8 << '\n' << &myTime9 << '\n' << std::endl;
}