错误：使用未声明的标识符“类名”

Question

我正在尝试实施 class“时间”。 我已将所有声明放在 Time.h 中，将实现放在 Time.cpp 中。 然后我在一个单独的文件 Test.cpp 中测试它。 编译 Time.cpp 文件时，出现此错误error: use of undeclared identifier 'Time' 。 这是代码，

时间.h

#ifndef _TIME_H_
#define _TIME_H_

#include <iostream>

class Time
{
    public:
        Time();
        
        // extra constructor not provided in part 3
        Time(int hour, int min = 0, int h = 0);
        
        void setTime(int h, int m, int s);

        Time operator+(unsigned int n) const;
        Time& operator+=(unsigned int n);
        Time& operator++(); // prefix version
        Time operator++(int n); // postfix version

        // member functions you have to implement
        bool operator==(const Time &t) const;
        bool operator!=(const Time &t) const;
        bool operator<(const Time &t) const;
        bool operator<=(const Time &t)const;
        Time operator-(unsigned int n) const; 
        Time& operator-=(unsigned int n);
        Time& operator--(); // prefix version
        Time operator--(int n); // postfix version

        int getHour() const;
        int getMin() const;
        int getSec() const;

        
    private:
        int hour, min, sec;

        // output in universal format
        friend ostream& operator<<(ostream& o, const Time& t);

        // new friend functions you have to implement
        friend bool operator>(const Time& t1, const Time& t2);
        friend bool operator>=(const Time& t1, const Time& t2);
        friend int operator%(const Time& t1, const Time& t2);
};

#endif

时间.cpp

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

using namespace std;

Time::Time()
{
    hour = min = sec = 0;
}

Time::Time(int h, int m, int s)
{
    setTime(h, m, s);
}

void Time::setTime(int h, int m, int s)
{
    hour = (h>=0 && h<24) ? h : 0;
    min = (m>=0 && m<60) ? m : 0;
    sec = (s>=0 && s<60) ? s : 0;
}

int Time::getHour() const
{
    return hour;
}

int Time::getMin() const
{
    return min;
}

int Time::getSec() const
{
    return sec;
}

Time& Time::operator+=(unsigned int n)
{
    sec += n;
    if (sec>=60)
    { 
        min += sec/60;
        sec %= 60;
        if (min>=60)
        {
            hour = (hour + min/60)%24; 
            min %= 60;
        }
    }
    return *this;
}

Time& Time::operator-=(unsigned int n)
{
    sec -= n;
    if (sec < 0)
    {
        min -= ceil((sec * (-1)) / 60.0);
        sec %= 60;
        if (sec < 0)
        {
            sec += 60;
        }
        if (min < 0)
        {
            hour -= ceil((min * (-1)) / 60.0);
            min %= 60;
            if (min < 0)
            {
                min += 60;
            }
        }
    }
    return *this;
}

Time Time::operator+(unsigned int n) const
{
    Time tCopy(*this);
    tCopy += n;
    return tCopy;
}

Time Time::operator-(unsigned int n) const
{
    Time tCopy(*this);
    tCopy -= n;
    return tCopy;
}

Time& Time::operator++()  // prefix version
{
    *this += 1;
    return *this;
}

Time& Time::operator--()  // prefix version
{
    *this -= 1;
    return *this;
}

Time Time::operator++(int n)   // postfix version
{
    Time tCopy(*this);
    *this += 1;
    return tCopy;
}

Time Time::operator--(int n)   // postfix version
{
    Time tCopy(*this);
    *this -= 1;
    return tCopy;
}

bool Time::operator==(const Time &t) const
{
    if(hour == t.getHour() && min == t.getMin() && sec == t.getSec())
    {
        return true;
    }
    return false;
}

bool Time::operator!=(const Time &t) const
{
    if(*this == t)
    {
        return false;
    }
    return true;
}

bool Time::operator<(const Time &t) const
{
    if(hour < t.getHour() || min < t.getMin() || sec < getSec())
    {
        return true;
    }
    return false;
}

bool Time::operator<=(const Time &t)const
{
    if(*this < t || *this == t)
    {
        return true;
    }
    return false;
}

ostream& operator<<(ostream& o, const Time &t)
{
    o << setfill('0') << setw(2) << t.hour << ":" << setw(2) << t.min << ":" << setw(2) << t.sec;
    return o;
}

bool operator>(const Time& t1, const Time& t2)
{
    if(t1 < t2 || t1 == t2)
    {
        return false;
    }
    return true;
}

bool operator>=(const Time& t1, const Time& t2)
{
    if(t1 < t2)
    {
        return false;
    }
    return true;
}

int operator%(const Time& t1, const Time& t2)
{
    int totalSec = 24 * 60 * 60;
    int earlyTime = (t1.getHour() * 3600) + (t1.getMin() * 60) + (t1.getSec());
    int lateTime = (t2.getHour() * 3600) + (t2.getMin() * 60) + (t2.getSec());
    if(earlyTime <= lateTime)
    {
        return lateTime - earlyTime;
    }
    else
    {
        return (totalSec - earlyTime) + lateTime;
    }
}

错误截图

代码有什么问题？

Answer 1

_TIME_H_是问题所在。 它是一个保留标识符。 将您的 include guard 更改为不同的标识符，例如TIME_H_ 。

来自 cppreference 的引用：

• 以下划线开头后跟大写字母的标识符是保留的；

[...]

这里的“保留”是指标准库头文件#define 或声明此类标识符以满足其内部需要，编译器可能会预定义此类非标准标识符，并且该名称修改算法可能会假设其中一些标识符未被使用。 如果程序员使用这样的标识符，则行为是未定义的。

我怀疑 header <time.h>使用它作为它自己的包含保护，而其他标准包含之一可能包含这个（所有标准库头文件都允许包含任何其他标准库头文件）。

Answer 2

Time是一个过于笼统的术语。 _TIME_H_可能由其中一个系统定义，并且在预处理过程中会跳过您的 header。

如果您使用-save-temps运行编译器，它会将预处理器 output 保留在名为Time.ii的文件中。 您将能够看到编译器没有看到Time.h中的任何代码。