Is there a min function that accepts any number of arguments?

[Peng Yu]

Hi,

I'm wondering if there is a min function (in boost, maybe?) that
accepts any number of arguments? std::min only accepts two arguments.
If I want to get the minimum number out of many, I have use std::min
many times, which is not convenient.

Thanks,
Peng

 

[Leandro Melo]

Hi,

I'm wondering if there is a min function (in boost, maybe?) that
accepts any number of arguments? std::min only accepts two arguments.
If I want to get the minimum number out of many, I have use std::min
many times, which is not convenient.

Hi.

Maybe, you could iterate through the elements with a for (or something
similar) keeping track of the smallest element. This is pretty simple.

 

[Peng Yu]

Hi.

Maybe, you could iterate through the elements with a for (or something
similar) keeping track of the smallest element. This is pretty simple.

Hi,

The numbers are at compile time not at runtime time. It has to some
how use the template to implement such a function.

Thanks,
Peng

 

[Peng Yu]

How many numbers are we talking about? You can roll your own 'min_of'
implementation using recursive template definitions in no time, can't you?

template<class T> T min_of(T t1, T t2) {
return std::min(t1, t2);}

template<class T> T
min_of(T t1, T t2, T t3) {
return std::min(min_of(t1, t2), t3);}

template<class T> T
min_of(T t1, T t2, T t3, T t4) {
return std::min(min_of(t1, t2, t3), t4);}

template<class T> T
min_of(T t1, T t2, T t3, T t4, T t5) {
return std::min(min_of(t1, t2, t3, t4), t5);}

... and so on

Hi Victor,

I can define my own version of min_of. But I feel that the min
function that accepts any number of arguments is a reasonable
extension to std::min, and boost in many ways extends the original C++
library. I think that it is worthwhile to add such function in boost
if it is not there. At this point, since the issue is with boost,
maybe I should post the message at boost mailing list.

Thanks,
Peng

 

[Juha Nieminen]

I'm wondering if there is a min function (in boost, maybe?) that
accepts any number of arguments? std::min only accepts two arguments.
If I want to get the minimum number out of many, I have use std::min
many times, which is not convenient.

With the current C++ I think it's rather difficult to implement such a
function which takes a variable number of arguments (while probably
possible, it won't be type-safe, and you would probably have to specify
explicitly the number of variables as a parameter, making it more
cumbersome).

However, AFAIK, with the upcoming standard C++ it will be possible to
create such a function in a completely type-safe way (and without having
to specify the number of arguments explicitly), by using so-called
variadic templates. However, this is not yet standardized.

 

[Leandro Melo]

  With the current C++ I think it's rather difficult to implement such a
function which takes a variable number of arguments (while probably
possible, it won't be type-safe, and you would probably have to specify
explicitly the number of variables as a parameter, making it more
cumbersome).

  However, AFAIK, with the upcoming standard C++ it will be possible to
create such a function in a completely type-safe way (and without having
to specify the number of arguments explicitly), by using so-called
variadic templates. However, this is not yet standardized.

GCC has some implementations already. (Using flag -std=c++0x.)

 

[Peng Yu]

Yes there is.

void fn( const vector<int>& vec )
{
if ( !vec.empty() ) {
int m = *min_element( vec.begin(), vec.end() );
// m now equals the minimum value of the vector
// so use it
cout << "minimum value == " << m << '\n';
}

}

Hi,

It seems that many people misunderstood my original post. What I'm
looking for is of the syntax,

min(x1, x2, x3, x4, ..., x_n); // where n can be any number.

Thanks,
Peng

 

[Michael DOUBEZ]

Peng Yu a écrit :

It seems that many people misunderstood my original post. What I'm
looking for is of the syntax,

min(x1, x2, x3, x4, ..., x_n); // where n can be any number.

This is hideous but you could do something like:

template<typename T, class Compare = std::less<T> >
struct min_of
{
const T& value;

min_of(const T& v):value(v){}

min_of operator()(const T& v) const
{
return (Compare()(value,v))?*this:min_of(v);
}
};


int main()
{
int a=-10;
const int b=20;
int min_val=min_of<int>(1)(a)(2)(b)(-1)(4).value;
std::cout<<min_val<<std::endl;

return 0;
}

 

[Nick Keighley]

I'm wondering if there is a min function (in boost, maybe?) that
accepts any number of arguments? std::min only accepts two arguments.
If I want to get the minimum number out of many, I have use std::min
many times, which is not convenient.

put them in a container and use min_element()?
You really want to use Lisp don't you?

 

[Juha Nieminen]

It seems that many people misunderstood my original post.

I don't think they misunderstood. They are just saying "there's no
easy way of doing that with the current C++, but here is an alternative
approach". For some reason they want to leave out the first part rather
then say it explicitly.

 

[Daniel T.]

Hi,

It seems that many people misunderstood my original post. What I'm
looking for is of the syntax,

min(x1, x2, x3, x4, ..., x_n); // where n can be any number.

You have an arbitrary number of variables that are all related, but
you don't have them in an array? That's silly.

Put your variables in a vector and call min_element.

 

[Marco Manfredini]

Hi,

I'm wondering if there is a min function (in boost, maybe?) that
accepts any number of arguments? std::min only accepts two arguments.
If I want to get the minimum number out of many, I have use std::min
many times, which is not convenient.

Well, if you really want it:
----------------
namespace peng_yu
{
template<typename T>
struct tmp_min_t
{
const T &item;
tmp_min_t(const T &n) : item(n) {}
operator const T& () const { return item; }
};

struct minimum_t {} minimum;

template<typename T>
inline tmp_min_t<T> operator , (minimum_t, const T &x)
{
return tmp_min_t<T>(x);
}
template<class T>
inline tmp_min_t<T> operator , (tmp_min_t<T> a, const T &x)
{
if (a.item<=x) return a;
else return tmp_min_t<T>(x);
}
}

#define MIN(...) (peng_yu::minimum,__VA_ARGS__)

#include <iostream>

int main()
{
std::cout
<< MIN(6,5,4,5,1,5,3,5,7,4,3,4,6,8,5,3,2,-23,5,2,2,4,6,4,4,3,4)
<< std::endl;
}

 

[kwikius]

There will be, in the next C++ standard. But not yet.

Well. If it returns by const ref like the current one then I'll
certainly be rolling my own again.. as I do now ;-)


regards
Andy Little