Passing multiple variables using function

I'm creating a function right now but I want to pass all the text I want to render in one function call. Is it possible? Just like what the stringstream do.

Let's say I want to pass:

Code:

---

stringstream text;
text << "Frame: " << fps << " X: " << x<< " Y: " << y;

renderText(text, 10, 10, 10); // void renderText( what should I put here?, int x, int y, int fsize);

---

is there any other way around?

You can make a class that overloads operator<<. (Remove const-ness if rendering modifies the state of TextRenderer, make friends as needed etc.)

Code:

---

#include <iostream>

class TextRenderer
{
};

template <class T>
const TextRenderer& operator<< (const TextRenderer& renderer, const T& value)
{
    std::cout << value;
    return renderer;
}

int main()
{
    TextRenderer output;
    output << "X is " << 10 << ", Y is " << 20 << '\n';
}

---

Another way might be to create a function that accepts a string and build the string with stringstream (this doesn't look very nice):

Code:

---

#include <iostream>
#include <sstream>
#include <string>
void render_text(const std::string& msg)
{
    std::cout << msg;
}

int main()
{
    std::stringstream ss;
    render_text(static_cast<std::stringstream&>(ss << "X is " << 10 << ", Y is " << 20 << '\n').str());
}

---

Yet another way might be to get boost and use boost::format to build the string.

Code:

---

#include <iostream>
#include <string>
#include <boost/format.hpp>

void render_text(const std::string& msg)
{
    std::cout << msg;
}

int main()
{
    render_text(boost::str((boost::format("X is %d, Y is %d\n") % 10 % 20)));
}

---

In any case, without variadic templates (C++0x feature) there is no good way to create a function that accepts an arbitrary number of arguments with arbitrary types.

O_o

Do you mean you want to combine all of that source into one line?

Code:

---

renderText((stringstream() << "Frame: " << fps << " X: " << x<< " Y: " << y), 10, 10, 10);

---

Do you mean you just want to pass the 'std::stringstream' instance after you've constructed the string? (As you've done in the post.)

Do you mean you just want to pass the string you've constructed without using 'std::stringstream' in the signature?

Code:

---

renderText(text.str(), 10, 10, 10);

---

Why not accept a constant reference to a 'std::string' and provide overloads to do the other bits?

Code:

---

void renderText(const std::string &, int x, int y, int fsize);

---

Soma

You could do something like this...

Code:

---

#include <vector>
#include <string>
#include <assert.h>
#include <iostream>

template<typename T> class MltArgs
{
public:
        //MltArgs() { }

        //MltArgs(T Val)
        //{
        //        m_Args.push_back(Val);
        //}

        MltArgs& operator << (T Val)
        {
                m_Args.push_back(Val);
                return *this;
        }

        //MltArgs& operator << (const MltArgs& Val)
        //{
        //        for (std::size_t i = Val.NumOfArgs(); i++)
        //                m_Args.push_back(Val[i]);
        //        return *this;
        //}

        std::size_t NumOfArgs()
        {
                return m_Args.size();
        }

        T& operator [] (std::size_t i)
        {
                assert(i < m_Args.size());
                return m_Args[i];
        }

private:
        std::vector<T> m_Args;
};

void foo(MltArgs<std::string>& Args)
{
        std::cout << "The following arguments were passed:\n";
        for (std::size_t i = 0; i < Args.NumOfArgs(); i++)
                std::cout << Args[i] << std::endl;
}

int main()
{
        std::string World = "world!";
        foo( (MltArgs<std::string>() << "Hello" << "there" << World) );
}

---

The only problem is the lot of copying, but otherwise extra trickiness is required to make implicit conversions work. I'm open to suggestions on that one.

O_o

If you are going to go that root, spawning a class for indirection, you may as well employee templates, overload 'operator ,' and cache a reference whenever possible. At least then you don't have to lose type information.

Soma

You are better at this than me...
You are allowed to type an example :)
This was just a short implementation written from scratch that "worked", although not really well.

I don't like posting examples that depend on my own stuff. (I may when I get it all fixed.)

I don't like posting examples that depend on Boost. (I don't even use it anymore.)

You need a lot of meta-programming primitives to do this correctly. (I don't want to code them all before posting.)

I will simply avoid the issues. (This will not work if constant character strings are used directly for example.)

This is the most basic form of what I was suggesting. It uses 'operator ,' as a means of concatenating pairs to generate a modified type list that always stores a constant reference.

Soma

Code:

---

#include <iostream>
#include <string>

struct empty_type{};

template
<
  typename node_F = empty_type,
  typename list_F = empty_type
>
struct reference_list
{
  typedef reference_list<node_F, list_F> type;
  reference_list
  (
      const node_F & n_f,
      const list_F & l_f
  ):
      n_m(n_f),
      l_m(l_f)
  {
  }
  template
  <
      typename type_FR
  >
  typename reference_list<type_FR, typename reference_list<node_F, list_F>::type>::type operator ,
  (
      const type_FR & f
  )
  {
      return(typename reference_list<type_FR, typename reference_list<node_F, list_F>::type>::type(f, *this));
  }
  const node_F & n_m;
  const list_F & l_m;
};

template
<
  typename node_F
>
struct reference_list<node_F, empty_type>
{
  typedef reference_list<node_F, empty_type> type;
  reference_list
  (
      const node_F & n_f
  ):
      n_m(n_f)
  {
  }
  template
  <
      typename type_FR
  >
  typename reference_list<type_FR, typename reference_list<node_F, empty_type>::type>::type operator ,
  (
      const type_FR & f
  )
  {
      return(typename reference_list<type_FR, typename reference_list<node_F, empty_type>::type>::type(f, *this));
  }
  const node_F & n_m;
};

template <> struct reference_list<empty_type, empty_type>
{
  typedef reference_list<empty_type, empty_type> type;
  reference_list()
  {
  }
  template
  <
      typename type_FR
  >
  typename reference_list<type_FR, empty_type>::type operator ,
  (
      const type_FR & f
  )
  {
      return(typename reference_list<type_FR, empty_type>::type(f));
  }
};

template
<
  typename node_F
>
void do_something
(
  const reference_list<node_F, empty_type> & f,
  int x_f,
  int y_f,
  int size_f
)
{
  std::cout << "Data:(" << f.n_m << ") X:(" << x_f << ") Y:(" << y_f << ") Size:(" << size_f << ")\n";
}

template
<
  typename node_F,
  typename list_F
>
void do_something
(
  const reference_list<node_F, list_F> & f,
  int x_f,
  int y_f,
  int size_f
)
{
  do_something(f.l_m, x_f, y_f, size_f);
  std::cout << "Data:(" << f.n_m << ") X:(" << x_f << ") Y:(" << y_f << ") Size:(" << size_f << ")\n";
}

typedef reference_list<> arguments_list;
arguments_list join;

int main()
{
  do_something((join, std::string("Hello"), ',', ' ' , std::string("World"), '!', 1, 2.0, 3.0f), 10, 10, 10);
  return(0);
}

---

Another big, tricky example from you! Yes!
It's a shame you won't post complete examples, but I can understand your reluctance. Not about boost, though. Terrific, that. Boost.
The only thing that I know I might punch a hole in is that it concatenates the arguments instead of preserving them... not good for passing multiple arguments to a function. It kind of reinvents the wheel with stringstreams, but using "," instead of "<<", no?

I'd really big interested in a more generic solution for passing multiple arguments until compilers start supporting the new C++0x solution.
Not that such a solution would be required in this particular scenario, but meh, whatever. It's cool!

Quote:

---

Originally Posted by Elysia

You are better than this at me...

---

Perhaps your ego prevented you fingers from saying what you meant there :p.

It simply meant that phantomotap is a wizard with far more experience with template programming to pull off advanced stunts like this :)

Could you create a stream buffer that does the work of the function for every flush?

Quote:

---

The only thing that I know I might punch a hole in is that it concatenates the arguments instead of preserving them... not good for passing multiple arguments to a function.

---

It does concatenate the arguments. It preserves the actual arguments and the type of arguments. (The lack of support for constant character strings is the problem.)

Quote:

---

It kind of reinvents the wheel with stringstreams, but using "," instead of "<<", no?

---

This doesn't serialize the values associated with the types. This is on the other side of the universe. I've created a kind of variadic template using a specific purpose type list. I've then pealed off the type information with recursion--exactly as you will for C++0x variadic templates.

I've altered the example. I suggest you compile and run the example. You can see the untouched type information for yourself.

Quote:

---

Actually, not really.

---

^_^

There is a tremendous difference between "You are better at this than me..." and "You are better than this at me...".

Soma

Code:

---

#include <iostream>
#include <string>

struct empty_type{};

template
<
  typename node_F = empty_type,
  typename list_F = empty_type
>
struct reference_list
{
  typedef reference_list<node_F, list_F> type;
  reference_list
  (
      const node_F & n_f,
      const list_F & l_f
  ):
      n_m(n_f),
      l_m(l_f)
  {
  }
  template
  <
      typename type_FR
  >
  typename reference_list<type_FR, typename reference_list<node_F, list_F>::type>::type operator ,
  (
      const type_FR & f
  )
  {
      return(typename reference_list<type_FR, typename reference_list<node_F, list_F>::type>::type(f, *this));
  }
  const node_F & n_m;
  const list_F & l_m;
};

template
<
  typename node_F
>
struct reference_list<node_F, empty_type>
{
  typedef reference_list<node_F, empty_type> type;
  reference_list
  (
      const node_F & n_f
  ):
      n_m(n_f)
  {
  }
  template
  <
      typename type_FR
  >
  typename reference_list<type_FR, typename reference_list<node_F, empty_type>::type>::type operator ,
  (
      const type_FR & f
  )
  {
      return(typename reference_list<type_FR, typename reference_list<node_F, empty_type>::type>::type(f, *this));
  }
  const node_F & n_m;
};

template <> struct reference_list<empty_type, empty_type>
{
  typedef reference_list<empty_type, empty_type> type;
  reference_list()
  {
  }
  template
  <
      typename type_FR
  >
  typename reference_list<type_FR, empty_type>::type operator ,
  (
      const type_FR & f
  )
  {
      return(typename reference_list<type_FR, empty_type>::type(f));
  }
};

void do_something
(
  const std::string & f,
  int x_f,
  int y_f,
  int size_f
)
{
  std::cout << "std::string:(" << f << ") X:(" << x_f << ") Y:(" << y_f << ") Size:(" << size_f << ")\n";
}

void do_something
(
  const int & f,
  int x_f,
  int y_f,
  int size_f
)
{
  std::cout << "int:(" << f << ") X:(" << x_f << ") Y:(" << y_f << ") Size:(" << size_f << ")\n";
}

void do_something
(
  const double & f,
  int x_f,
  int y_f,
  int size_f
)
{
  std::cout << "double:(" << f << ") X:(" << x_f << ") Y:(" << y_f << ") Size:(" << size_f << ")\n";
}

void do_something
(
  const float & f,
  int x_f,
  int y_f,
  int size_f
)
{
  std::cout << "float:(" << f << ") X:(" << x_f << ") Y:(" << y_f << ") Size:(" << size_f << ")\n";
}

template
<
  typename node_F
>
void do_something
(
  const node_F & f,
  int x_f,
  int y_f,
  int size_f
)
{
  std::cout << "Data:(" << f << ") X:(" << x_f << ") Y:(" << y_f << ") Size:(" << size_f << ")\n";
}

template
<
  typename node_F
>
void do_something
(
  const reference_list<node_F, empty_type> & f,
  int x_f,
  int y_f,
  int size_f
)
{
  do_something(f.n_m, x_f, y_f, size_f);
}

template
<
  typename node_F,
  typename list_F
>
void do_something
(
  const reference_list<node_F, list_F> & f,
  int x_f,
  int y_f,
  int size_f
)
{
  do_something(f.l_m, x_f, y_f, size_f);
  do_something(f.n_m, x_f, y_f, size_f);
}

typedef reference_list<> arguments_list;
arguments_list join;

int main()
{
  do_something((join, std::string("Hello"), ',', ' ' , std::string("World"), '!', 1, 2.0, 3.0f), 10, 10, 10);
  return(0);
}

---

Quote:

---

Originally Posted by phantomotap

^_^

There is a tremendous difference between "You are better at this than me..." and "You are better than this at me...".

---

o_O
I didn't realize I had mixed up the order of the words... I didn't think of it.
Hehe. Oops, yes, your order is the correct one ^_^