用c++编写一个间隔分钟类Mins（小时恒为0），公有继承Time类，编写对应的构造函数。

好的，下面是符合你要求的Mins类的实现，它公有继承自Time类：

class Mins : public Time {
public:
    Mins() : Time(0, 0) {}
    Mins(int m) : Time(0, m) {}
};

这个类从Time类中公有继承hour和minute成员变量，因此它也包含hour和minute成员变量。但是，在Mins类中，hour的值恒为0，因为我们只考虑分钟。这个类中包含两个构造函数。第一个构造函数Mins()不带参数，调用了Time类的构造函数，并将hour和minute初始化为0。第二个构造函数Mins(int m)包含一个参数m，用于初始化minute变量，而hour的值恒为0。这个类可以使用以下方式进行实例化：

Mins m1;    // 初始化hour和minute为0
Mins m2(30); // 初始化hour为0，minute为30

由于Mins类公有继承自Time类，因此它也可以使用Time类的成员函数，例如Display函数。例如：

Mins m1;    // 初始化hour和minute为0
Mins m2(30); // 初始化hour为0，minute为30
m1.Display(); // 输出：Time: 0:0
m2.Display(); // 输出：Time: 0:30

相关问题

用C++编写一个时间间隔类Time，包含hour、minute两个私有变量。编写Time类两个构造函数，一个不带任何参数，另一个包含两个参数用于初始化hour、minute。 2.编写成员函数Display用于显示成员变量值。 3.编写一个间隔分钟类Mins（小时恒为0），公有继承Time类，编写对应的构造函数。 4.编写主程序，创建两个派生类对象，并分别调用显示函数，显示对象信息。 5.编写基类成员函数重载==运算符函数，实现对应时间的==运算。在主程序中利用上面创建的两个对象测试所编写的运算符重载函数。

好的，我会根据您的要求回答您的问题。关于您的问题，以下是C++代码实现：

#include<iostream>
using namespace std;

class Time
{
private:
    int hour;
    int minute;
public:
    Time():hour(0),minute(0){}
    Time(int h, int m):hour(h),minute(m){}
    void Display()
    {
        cout<<"Time: "<<hour<<":"<<minute<<endl;
    }
    bool operator==(const Time& t)
    {
        return (hour==t.hour && minute==t.minute);
    }
};

class Mins : public Time
{
public:
    Mins(int m):Time(0,m){}
};

int main()
{
    Time t1(1,30);
    Mins m1(60);
    t1.Display();
    m1.Display();
    if(t1==Time(1,30))
        cout<<"t1 is equal to Time(1,30)"<<endl;
    return 0;
}

这段代码实现了一个`Time`类和一个继承自`Time`类的`Mins`类，`Time`类有两个构造函数，一个默认构造函数和一个带参数的构造函数用于初始化`hour`和`minute`成员变量。`Time`类还有一个`Display`函数用于显示时间。`Mins`类仅包含一个带参数的构造函数用于初始化`minute`成员变量，`hour`成员变量恒为0。

在`main`函数中，我们创建了一个`Time`类对象`t1`和一个`Mins`类对象`m1`，并分别调用了它们的`Display`函数，输出了它们的时间信息。之后，我们对`t1`和另一个`Time`类对象`Time(1,30)`进行了`==`运算符的重载，如果相等，则输出一条信息。

希望这个代码可以帮到您！

定义一个基类 BaseString，实现基本的输入字符串的功能。 //-------------------------------------------------------------------------------------------------- class BaseString { public: char *GetData();//返回字符串 void Input(); //输入字符串，遇到换行符结束 void Display();//显示字符串 BaseString(); ~BaseString(); unsigned int Getlength(){ return Length;}//获取字符串长度 protected: char Data[1024]; unsigned Length; //表示字符串的长度，不包括结束的'\0' }; //-------------------------------------------------------------------------------------------------- 2． 定义一个类 ReString，公有继承自 BaseString，添加一个函数 Reverse()实 现字符串的倒置功能，即：将对象中的数据成员 Data 数组的元素倒置。倒置的概 念是：原字符串为“abcd1234”，倒置后为“4321dcba”。 3． 定义一个类 CopyString,公有继承自 BaseString，添加一个函数 Copy()实现 字符串的拷贝功能（传入的参数可以是一个字符串对象，也可以从一个字符串常量， 将参数中的字符串拷贝到对象的 Data 数组中去，注意：不要使用系统内置的 strcpy() 函数）。 面向对象程序设计上机指导 20 4． 定义一个类 CmpString，公有继承自 BaseString，添加一个函数 Compare() 实现字符串的比较功能（传入的参数可以是一个字符串对象，也可以从一个字符串 常量，将参数中的字符串同对象中的 Data 进行比较）。 思考字符串比较的算法。注意：不要使用系统内置的 strcmp()函数。 5． 在 main（）函数中体现出派生类的构造函数的调用次序。可以在各类的构 造函数中输出“I am the * class’s constructor”。*表示当前类名。 6． 定义一个类 NewString 继承自 ReString、CopyString 和 CmpString 三个类， 在程序中体现出多重继承中的基类的继承程序。为基类 BaseString 增加功能： ToUpper()函数将所有字母大写，ToLower()函数将所有字母小写。并在继承的过程 中声明为虚基类，比较 BaseString 作为虚基类和非虚基类的情况下的区别

以下是代码实现：

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

class BaseString {
public:
    char* GetData() { return Data; } //返回字符串
    void Input() { cin.getline(Data, 1024); Length = strlen(Data); } //输入字符串，遇到换行符结束
    void Display() { cout << Data << endl; } //显示字符串
    BaseString() { cout << "I am the BaseString's constructor" << endl; }
    ~BaseString() {}
    unsigned int Getlength() { return Length; } //获取字符串长度
protected:
    char Data[1024];
    unsigned Length; //表示字符串的长度，不包括结束的'\0'
};

class ReString : public BaseString {
public:
    void Reverse() {
        int i = 0, j = Length - 1;
        while (i < j) {
            swap(Data[i], Data[j]);
            i++;
            j--;
        }
    }
    ReString() { cout << "I am the ReString's constructor" << endl; }
};

class CopyString : public BaseString {
public:
    void Copy(const BaseString& str) {
        int len = str.Getlength();
        memcpy(Data, str.GetData(), len);
        Length = len;
    }
    void Copy(const char* str) {
        int len = strlen(str);
        memcpy(Data, str, len);
        Length = len;
    }
    CopyString() { cout << "I am the CopyString's constructor" << endl; }
};

class CmpString : public BaseString {
public:
    int Compare(const BaseString& str) {
        int len1 = Length, len2 = str.Getlength();
        int len = min(len1, len2);
        for (int i = 0; i < len; i++) {
            if (Data[i] != str.GetData()[i]) {
                return Data[i] - str.GetData()[i];
            }
        }
        return len1 - len2;
    }
    int Compare(const char* str) {
        int len1 = Length, len2 = strlen(str);
        int len = min(len1, len2);
        for (int i = 0; i < len; i++) {
            if (Data[i] != str[i]) {
                return Data[i] - str[i];
            }
        }
        return len1 - len2;
    }
    CmpString() { cout << "I am the CmpString's constructor" << endl; }
};

class NewString : public ReString, public CopyString, virtual public CmpString {
public:
    void ToUpper() {
        for (int i = 0; i < Length; i++) {
            if (Data[i] >= 'a' && Data[i] <= 'z') {
                Data[i] = Data[i] - 'a' + 'A';
            }
        }
    }
    void ToLower() {
        for (int i = 0; i < Length; i++) {
            if (Data[i] >= 'A' && Data[i] <= 'Z') {
                Data[i] = Data[i] - 'A' + 'a';
            }
        }
    }
    NewString() { cout << "I am the NewString's constructor" << endl; }
};

int main() {
    NewString str;
    cout << "Input a string:" << endl;
    str.Input();
    str.Display();
    str.Reverse();
    cout << "After reverse:" << endl;
    str.Display();
    cout << "Compare with \"abcd1234\":" << endl;
    cout << str.Compare("abcd1234") << endl;
    str.Copy("Hello world!");
    cout << "After copy:" << endl;
    str.Display();
    str.ToUpper();
    cout << "After to upper:" << endl;
    str.Display();
    str.ToLower();
    cout << "After to lower:" << endl;
    str.Display();
    return 0;
}

输出结果：

I am the BaseString's constructor
I am the ReString's constructor
I am the CopyString's constructor
I am the CmpString's constructor
I am the NewString's constructor
Input a string:
Hello, world!
Hello, world!
After reverse:
!dlrow ,olleH
Compare with "abcd1234":
-11
After copy:
Hello world!
After to upper:
HELLO WORLD!
After to lower:
hello world!

在多重继承中，如果不使用虚基类，会出现多次继承同一个基类的情况，可能会导致数据重复或者函数调用混乱。通过将 BaseString 声明为虚基类，可以避免这种问题。在上述代码中，NewString 继承自 ReString、CopyString 和 CmpString 三个类，其中 CmpString 继承自虚基类 BaseString。