End of a variable argument list

**laserlight** · 08-29-2011

Originally Posted by tabstop

The C++ way to do it, as also mentioned above, is to use a std::vector, which is an object that can be resized at will and that does know start and end.

I would not say that that is the C++ way to do it, considering that std::max_element makes use of a range denoted by an iterator pair, rather than a vector.

Originally Posted by manasij7479

Here is an example...of that function..

Yuck

**manasij7479** · 08-29-2011

Originally Posted by laserlight

Yuck

Why ? ...Is iterating better than popping out the last each time ?

**Elysia** · 08-29-2011

Yes, it is.
(Why?)

**manasij7479** · 08-29-2011

Originally Posted by Elysia

Yes, it is.
(Why?)

I just realised that just iterating does the same thing..just without the popping... so it'd be better..

@laserlight : Any other yucky points ?

Code:

template<class T>
T my_max(std::vector<T> v)
{
    T temp=v[0];
    for(auto x:v)
        if(x>temp)
            temp=x;
    return temp;
}

**Elysia** · 08-29-2011

The "class" keyword is used for backward compatibility. The new keyword for use in templates is really "typename".
Consider passing the vector by (const) reference.
Ideally, I'd use std::initializer_list instead of std::vector.

**King Mir** · 08-29-2011

Originally Posted by Elysia

It does not know how many arguments were passed nor does it care. That's why it should be avoided.

No, it should be avoided because it does not enforce type safety.

**Elysia** · 08-29-2011

OK yes, you're right. I see my point got across incorrectly.
My point was that it was one of the reasons to avoid it, and not the only or the reason. There are many reasons to avoid it.

**Elkvis** · 08-31-2011

why not use variadic templates? it really seems like it would be the C++ way to do exactly this.

**Elysia** · 08-31-2011

Variadic templates allow for a infinite amount of template arguments or types. So if it isn't types, then it must be static arguments (known at compile time).
For runtime arguments, std::initializer_list is exactly what was created for that purpose.

**manasij7479** · 08-31-2011

Originally Posted by Elkvis

why not use variadic templates? it really seems like it would be the C++ way to do exactly this.

Template arguments and function arguments aren't the same thing, though they could be used in this case if the number list is a compile time constant.

**Elkvis** · 08-31-2011

Originally Posted by Elysia

Variadic templates allow for a infinite amount of template arguments or types. So if it isn't types, then it must be static arguments (known at compile time).
For runtime arguments, std::initializer_list is exactly what was created for that purpose.

I'll agree that std::initializer_list is an excellent way to do this; however, there's no reason why you couldn't write the code (and its accompanying documentation) such that the function expects only int parameters, and assumes internally that they are integer values. you could then recursively run through the list and add each parameter to a vector, from which you could then determine the largest value, or whatever you like. from the perspective of the user of the function in question, the variadic template method might actually be a little quicker and more intuitive.

with regard to the initializer_list method, is there a reason why you can't make the function accept a vector and pass it an initializer list? I've tested the following code with g++ 4.6, and it compiles perfectly:

Code:

int foo(std::vector<int> vInt)
{
  int largest = vInt.front();
  for (int i : vInt)
  {
    if (i > largest) largest = i;
  }
  return largest;
}

int bar()
{
  return foo({1, 2, 3, 4, 5, 6, 7, 8, 9, 0});
}

**Elysia** · 08-31-2011

Originally Posted by Elkvis

I'll agree that std::initializer_list is an excellent way to do this; however, there's no reason why you couldn't write the code (and its accompanying documentation) such that the function expects only int parameters, and assumes internally that they are integer values. you could then recursively run through the list and add each parameter to a vector, from which you could then determine the largest value, or whatever you like.

There is nothing stopping you from doing that, except perhaps some extra overhead.
But then again, with an initializer list, there's no point in doing so.
It's good for C++03 code, though.

from the perspective of the user of the function in question, the variadic template method might actually be a little quicker and more intuitive.

This isn't a variadic template method, and it wouldn't work properly.

with regard to the initializer_list method, is there a reason why you can't make the function accept a vector and pass it an initializer list? I've tested the following code with g++ 4.6, and it compiles perfectly:

You are contradicting yourself. What is the question?

**GigaRoid** · 08-31-2011

Originally Posted by Elysia

There is no empty slot.
va_arg is dumb; it simply fetches a value adjacent in memory and increments that position each time you call it.
It does not know how many arguments were passed nor does it care. That's why it should be avoided.

I'm not sure if you're understanding... we have 5 arguments: smax(5,1,4,8,6). va_arg will keep going on forever, creating an infinite loop, so we have to stop it at the sixth argument. So either it returns some an empty value at six, or it returns 0, which won't help us at all. If it returns an empty value, we can check for that. If that doesn't work... is there any way for us to be able to find the number of arguments without user input?

EDIT: didn't see the second page there.

**Elysia** · 08-31-2011

Originally Posted by GigaRoid

So either it returns some an empty value at six, or it returns 0, which won't help us at all. If it returns an empty value, we can check for that. If that doesn't work... is there any way for us to be able to find the number of arguments without user input?

va_arg does neither. It simply returns whatever is written at that memory location. That is, if we can read that. If not, we'll likely get an access violation. In either case, it's undefined behavior.
Simply put, it's not possible without manual input to do this with va_arg, and this is because of its C nature. C does not hold your hand.
The C++ alternatives are more friendly, and that is why I recommend you look into those.