How to make operator overloading work properly inside friend function?

Question

I took a free copyright template code and modified for my own needs but still struggling to make it work. I would appreciate some help to understand.

The problem is that I don't really understand how overloading work especially with >> operator like in the example below. Why you return the object logger in the friend &operator function. I don't understand how to make void print(); work and interact with friend overloaded operator <<.

This is the example code:

#pragma once

#include <fstream>


namespace  Log{

    class LogFile {

        public:

            enum class logType { LOG_ALWAYS=0, LOG_OKAY, LOG_ERROR, LOG_WARNING, LOG_INFO};
            enum class writeType {FOUT=0, CFOUT, FCOUT, COUT};

            explicit LogFile(string fname = "[nameError]log.txt") : numWarnings(0U), numErrors(0U)
            {
                myFile.open(fname);

                if (myFile.is_open())
                    std::cout << "Log file was created successfully!" << std::endl << std::endl;

                else
                {
                    std::cout << "Fatal Error can't create log file!" << std::endl << "Please check Application permissions" << std::endl;
                    exit(1);
                }
            }

            ~LogFile()
            {
                if (myFile.is_open())
                {
                    myFile << std::endl << std::endl;
                    myFile << numWarnings << " warnings" << std::endl;
                    myFile << numErrors << " errors" << std::endl;
                    myFile.close();
                }
            }

            friend LogFile &operator << (LogFile &logger, const logType e_logtype)
            {

                //TO DO
                //logger.myFile << tm << "|      " << memUsed << "kb added|";
                //<< "000000.000 | 0.0000kb added |"


                switch (e_logtype)
                {
                case LogFile::logType::LOG_ALWAYS:
                    logger.myFile << " ALWAYS| ";
                    break;

                case LogFile::logType::LOG_OKAY:
                    logger.myFile << "   OKAY| ";
                    break;

                case LogFile::logType::LOG_ERROR:
                    logger.myFile << "  ERROR| ";
                    ++logger.numErrors;
                    break;

                case LogFile::logType::LOG_WARNING:
                    logger.myFile << "   WARN| ";
                    ++logger.numWarnings;
                    break;

                default:
                    logger.myFile << "   INFO| ";
                    break;
                }
                return logger;
            }

            friend LogFile &operator << (LogFile &logger, const char* text)
            {
                logger.myFile << tex    t << std::endl;
                return logger;
            }

            LogFile(const LogFile &) = delete;
            LogFile &operator= (const LogFile &) = delete;



            //THIS IS MY PART


            friend void print(LogFile &logger, const char* text, const logType e_logtype, const writeType e_writetype)
            {
                switch (e_writetype)
                {
                case LogFile::writeType::FOUT:
                    logger << LogFile::logType::e_logtype << text;
                    break;

                case LogFile::writeType::FCOUT:
                case LogFile::writeType::CFOUT:
                    std::cout << text << std::endl;
                    logger << LogFile::logType::e_logtype << text;
                    break;

                case LogFile::writeType::COUT:
                default:
                    std::cout << text << std::endl;
                    break;
                }
                return;
            }

        private:

            std::ofstream myFile;
            unsigned int numWarnings;
            unsigned int numErrors;

    };

}

The idea is to use it as a header and in main.cpp log everything by using:

using namespace Log;

LogFile mylog;
mylog.print("Test...", LOG_OKAY, FCOUT);

Where:

LOG_OKAY, LOG_ERROR, etc - types of log info.

COUT, FCOUT, CFOUT, FOUT - log to file or cout or both

Edited: I have solved that problem 3 weeks ago. Thanks to the answer from @zenith. I would post the solution with outlined code I have changed with points to them if the question was openned again. Thanks :)

What do you mean by "work and interact"? Does it not compile? Does it not produce the expected result? What is the expected result? — Emil Laine, Nov 01 '15 at 15:25
What makes you think there is a mistake? This is very poorly asked. — Lightness Races in Orbit, Nov 01 '15 at 15:25
Your `print` should neither be friend nor take a LogFile argument - remove both and you'll get a straightforward member function, which will let you call `mylog.print(...)`. — Eran, Nov 01 '15 at 15:29
@eran But I have `logger << LogFile::logType::e_logtype << text;` if i remove LogFile as argument logger will be undefined. — Kaspar Siricenko, Nov 01 '15 at 15:32
@KasparSiricenko, that's what `this` is for... Use `*this << LogFile::logType::e_logtype << text;`. — Eran, Nov 01 '15 at 15:34

score 1 · Accepted Answer · answered Nov 01 '15 at 15:32

1

I don't really understand why you return the object logger in the friend &operator function.

So that you can chain multiple calls like so:

logger << logtype << text << moretext;

And how to make void print work and interact with friend overloaded operators <<.

You can fix the compile errors by removing the LogFile::logType:: in front of e_logtype:

logger << e_logtype << text;

because e_logtype is not a member of LogFile::logType, it is an object of type LogFile::logType.

Also you're missing #include <string> using std::string and #include <iostream>.

answered Nov 01 '15 at 15:32

Emil Laine

41,598
9
101
157

Thanks. Btw I have read that you don't have to really #include iostream because it's already defined in stdafx. I'm confused again – Kaspar Siricenko Nov 01 '15 at 15:36
But `stdafx.h` is not a standard header. And what if `stdafx.h` someday no longer includes those? (Generally you should not rely on another header including things.) – Emil Laine Nov 01 '15 at 15:37
Ahhhh so you should include those iostream and fstream if you want to use the header somewhere else? – Kaspar Siricenko Nov 01 '15 at 15:38
@KasparSiricenko: You don't need to include `iostream` or `string` if they are included in `stdafx.h`. – dreamlax Nov 01 '15 at 15:39
@zenith: `stdafx.h` is used for header precompilation for Microsoft's C++ compiler – dreamlax Nov 01 '15 at 15:41
Ahhhh so you should include those iostream and fstream if you want to use the header somewhere else? – Kaspar Siricenko Nov 01 '15 at 15:41
@KasparSiricenko: Have a look at [this question](http://stackoverflow.com/questions/4726155/whats-the-use-for-stdafx-h-in-visual-studio) which explains the purpose of `stdafx.h`. – dreamlax Nov 01 '15 at 15:42
@zenith I have read exactly that one. The performance issues. – Kaspar Siricenko Nov 01 '15 at 15:44

How to make operator overloading work properly inside friend function?

1 Answers1