error: use of undeclared identifier "classname"

Question

I am trying to implement a class "Time". I have put all the declarations in Time.h and the implementations in Time.cpp. Then I am testing it in a seperate file Test.cpp. When compiling the Time.cpp file, I am getting this error, error: use of undeclared identifier 'Time'. Here is the code,

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

Time.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;
    }
}

Screenshot of Error

What is wrong in the code?

Answer 1

Time is a too generic term. _TIME_H_ is probably defined by one of the system includes, and your header is skipped during preprocessing.

If you run your compiler with -save-temps, it will leave the preprocessor output in a file named Time.ii. You'll be able to see that none of the code in Time.h was seen by the compiler.

Answer 2

_TIME_H_ is the problem. It is a reserved identifier. Change your include guard to a different identifier, e.g. TIME_H_.

Quote from cppreference:

• the identifiers that begin with an underscore followed by an uppercase letter are reserved;

[...]

"Reserved" here means that the standard library headers #define or declare such identifiers for their internal needs, the compiler may predefine non-standard identifiers of that kind, and that name mangling algorithm may assume that some of these identifiers are not in use. If the programmer uses such identifiers, the behavior is undefined.

I suspect that header <time.h> uses that as its own include guard and one of the other standard includes may include this one (all standard library headers are allowed to include any other standard library header).