im wanting to make a class called Log. with the template as follows


class Log

{

private:

std::ofstream outputFile;

SYSTEMTIME systemTimeBuffer;

public:

Log( std::wstring error1 );

Log( std::wstring error1, std::wstring error2 );

Log( std::wstring error1, std::wstring error2, std::wstring error3 );

Log( std::wstring error1, std::wstring error2, std::wstring error3,....... );

.........

........

~ Log();

}


here is my problem...i have a custom exception class with the decleration below

class InvalidArgumentException : public std::exception
{
private:
std::wstring m_message;
std::wstring m_argumentName;
std::wstring m_otherInfo;
public:
InvalidArgumentException( const std::wstring& argumentName );
virtual std::wstring what();
std::wstring getOtherInfo();
};


i have 2 functions that return strings.... what() and getOtherInfo()...obviously i could make my log class except 2 std::wstrings and implement it like that....but then the class MUST EXCEPT 2 strings...what if i or another user wants to use my log class later on and it only has 1 string i need to record info on? say if i or another user wants to use this log class in another program and my/their custom exception returns 3 strings....then they have to edit my class to accomodate for accepting more strings in the constructor. My question is how can i implement it so my log class will except any # of strings and be able to log the info accordingly in a .txt file? is this even possible? i guess im asking is it possible to have a variable number of arguments? or does anyone have any ideas to achieve what im trying to achieve?i dont wanna have to destroy and recreate the object each time i wanna insert a string in my file....plus it will keep printing the time for each time i open then log object! -thx for any advice

Ok, let me clarify what I think you mean. You would like to have a Log class that does something like this:

class Log {
  private:
    std::ofstream outFile;
    //..
  public:
    Log(const std::string& filename) : outFile(filename) { /*..*/ }; 
    
    void recordEntry(const std::string& S1) {
      //..
      outFile << S1;
    };

    void recordEntry(const std::string& S1, const std::string& S2) {
     //..idem
    };
    
    //... so one for any number of strings. 
};

Well, you might want to learn a few things about templates in C++, before going to deep into this Log class.

C++ does not really support variadic functions (i.e. functions with variable number of arguments) (actually, it does, but it's not type-safe and very ugly, and I don't really know how to use that obscure feature). So, basically, you would have to write a function overload for each different number of parameters (just restrict it to 10 or something like that).

I want to point out two things. First, if you use templates, you will not be restricted to only strings. You can make overloads that take any sequence of parameters of any type:

class Log {
 //.. as before ..
   //say for 3 arguments:
   template <typename A1, typename A2, typename A3>
   void recordEntry(A1 a1, A2 a2, A3 a3) {
     outFile << a1 << a2 << a3; //this will allow you to record anything that can be outputted to a ostream.
   };
};

Second, I want to point out that the upcoming C++ standard (now called C++0x) will include a new feature called variadic templates (templates with any number of arguments). Most recent compilers today support this feature already via a compilation flag "-std=c++0x" for GCC, and similarly for others. With this, you won't need to write more than two functions to do it all:

class Log {
  //..as before

    template <typename T>
    void recordEntry(T a1) {
      outFile << a1;
    };
    template <typename T, typename... Args>
    void recordEntry(T a1, Args... args) {
      outFile << a1;
      recordEntry(args...);
    };
};
Comments
Very thorough answer!
This article has been dead for over six months. Start a new discussion instead.