Handle unknown number of undefined objects for logging - c++

Question

Trying to reproduce something that in C# you would do something like this:
string FormatString(params object[] args) {
return string.Format(CultureInfo.InvariantCulture, args);
}
And in Obj-c it would look like this:
#include <stdarg.h>
void logObjects(id firstObject, ...) {
va_list args;
va_start(args, firstObject);
id obj;
for (obj = firstObject; obj != nil; obj = va_arg(args, id))
NSLog(#"%#", obj);
va_end(args);
}
logObjects(#"foo", [NSNumber numberWithInt:4], #"bar", nil);
I'm familiar with variable parameter length but not too sure how to store the args and then send them to std::cout. Is this even possible?
Notice! I want to send any kind of object which can handle the << operator. Just look at this function as a substitute for:
std::cout << "test" << someObject << int << someOtherObject;
I am using boost and would like to keep it platform independent. This function will be part of a logging class in a shared lib.

Answer 1

It doesn't work in C# too because the format string is missing anyway concept is clear. In C you can do something like this (as seen in dbgprint, if you have variadic macro feature)
#define printfex(...) printf(__VA_ARGS__)
If you're so lucky to use C++11 you can write this prototype:
template<class... T>
void printfex(const std::string& format, T... args);

Answer 2

You cannot use run-time variadic parameters in C++- that's a basic fact. You must use the same technique that the C++ streams do - operator overloading. Fortunately, C++ already contains such functionality.
void f(const std::stringstream& str) {
std::cout << str;
}
int main() {
int i = 5;
f(std::stringstream() << "i is equal to " << 5);
}

Answer 3

Sorry but I don't know very much about C#. Do you want to send a list of parameters to std::cout? That's not complicated:
void formatString (const std::vector<std::string>& args)
{
for (int i=0; i<args.size (); ++i)
{
std::cout << args[i];
}
std::cout << std::endl;
}
And you can store the elements in the following way:
std::vector test (2);
test[0] = "one";
test[1] = "two";
formatString (test);
UPDATE
Copy & Paste this into a .cpp file and compile it.
You have to implement the IPrintable interface for every class you want to log. Maybe is not the most efficient solution but it works.
#include <iostream>
#include <string>
#include <vector>
class IPrintable
{
public:
virtual ~IPrintable () { }
virtual std::string toString () const = 0;
};
class ClassA : public IPrintable
{
public:
std::string toString () const
{
std::string s = "Class A to string";
return s;
}
};
class ClassB : public IPrintable
{
public:
std::string toString () const
{
std::string s = "Class B to string";
return s;
}
};
void print (const std::vector<IPrintable*> args)
{
for (int i=0; i<args.size (); ++i)
{
std::cout << args[i]->toString () << std::endl;
}
}
int main (int argc, char* argv[])
{
ClassA a;
ClassB b;
std::vector<IPrintable*> v (2);
v[0] = &a;
v[1] = &b;
print (v);
return 0;
}