template for "AnySTLContainer" c++

Question

I am looking for a way to provide a function that takes a templated (STL) container, but requires its elements to be of a certain type (e.g. int).

These function calls should be VALID:

std::vector<int> Argument;
void foo( Argument );

std::list<int> Argument
void foo( Argument );

std::deque<int> Argument
void foo( Argument );

...etc

These function calls should be INVALID:

std::vector<float> Argument;
void foo( Argument );

std::list<double> Argument
void foo( Argument );

std::deque<char> Argument
void foo( Argument );

...etc

Is there a way to template "foo" such that containers of int are accepted, but containers with different element types are not accepted ?

Best, Ben

Just checking, do you really need a *container*? Do mere iterators not work? — user541686, Aug 20 '14 at 20:24
BTW: Must it be a standard-library container, or is any kind of conainer of `int` good enough? Maybe even immutable sequence? — Deduplicator, Aug 20 '14 at 20:41

quantdev · Answer 1 · 2014-08-20T21:00:09.647

13

Use the Standard Library semantics :

Pass a pair of iterators to foo, not a container : it makes your function much more generic
Use std::iterator_traits<Iterator>::value_type to get to the value type
static_assert the value type of the Iterator to be an int (or whatever type you want)

Example :

#include <list>
#include <vector>

template<typename Iterator>
void foo(Iterator begin, Iterator end)
{
    static_assert(std::is_same<int, typename std::iterator_traits<Iterator>::value_type>::value, 
                                "Invalid value type : must be int");
}

int main() {
    std::list<int> l1;
    std::vector<int> v1;

    foo(std::begin(l1), std::end(l1)); // OK
    foo(std::begin(v1), std::end(v1)); // OK

    std::vector<float> v2;
    foo(std::begin(v2), std::end(v2)); // Doesn't compile
}

Live demo

Note:

If foo needs to access specific member functions of the container (as noted by Deduplicator, this might happen for performance reasons), then you might need to stick with the Container argument :

Example : (Note the difference for getting at the value_type, as pointed by MooingDuck, this is required to make it work with arrays):

template <typename Container>
void foo(const Container& c)
{

    static_assert(std::is_same<int, std::iterator_type<decltype(std::begin(c))>::value_type>::value, "Invalid value type : must be int");

   // Use c member function(s)
}

edited Aug 20 '14 at 21:00

answered Aug 20 '14 at 20:24

quantdev

23,517
5
55
88

Depends. Using iterators can inhibit use of the proper algorithm, like `map.find`. – Deduplicator Aug 20 '14 at 20:35
@Deduplicator agreed, but here the OP has a non-member template function, so I don't think it applies. – quantdev Aug 20 '14 at 20:36
@quantdev The answer is ok for C++11. However, it's worth noting that, since C++14 is here, concepts are the best way to constrain a type. – edmz Aug 20 '14 at 20:37
Oh, it applies. How do you know he could not possibly used specialized faster algorithms if he only had the container instead of useless iterators? Of course, his container-function should delegate to an iterator-function for the general case, when it does not apply. – Deduplicator Aug 20 '14 at 20:38
6

@black Except concepts didn't make it into C++14 – Praetorian Aug 20 '14 at 20:38
@Praetorian As far as I know, yes they did. At least, concepts lite did. – edmz Aug 20 '14 at 20:41
1

@black [You don't know very far then](https://stackoverflow.com/questions/25387888/did-template-concepts-get-to-c14) – Praetorian Aug 20 '14 at 20:46
@Deduplicator yes I see. Note added ! – quantdev Aug 20 '14 at 20:48
@quantdev: container assert fails for arrays. I prefer `std::iterator_type::value_type`. – Mooing Duck Aug 20 '14 at 20:51
@MooingDuck : [works for me with arrays](http://ideone.com/Lfj8yJ) - but you definitely have a point – quantdev Aug 20 '14 at 20:55
@MooingDuck: Is there any case in which that's better than `decltype(*std::begin(c))`? – Deduplicator Aug 20 '14 at 20:56
@quantdev: the iterator form is perfect, that's why you got upvotes. The `void foo(const Container& c)` fails for arrays though. – Mooing Duck Aug 20 '14 at 20:57
@MooingDuck aah I see, of course you're right. Editing. – quantdev Aug 20 '14 at 20:58
@Deduplicator: I'm not 100% certain. `std::vector::iterator` is pretty weird, so maybe. – Mooing Duck Aug 20 '14 at 20:59
@MooingDuck: To my mind, using that one is an error all by itself. It's a shame they never removed that specialization... Still, that one is too weird to contemplate. – Deduplicator Aug 20 '14 at 21:03
@Deduplicator: the real shame is that neither C++11 nor C++14 even deprecated that atrocity… If they had we would possible have the chance to remove it in C++2X – MFH Aug 20 '14 at 21:52
`using std::begin;` then use raw `begin` to enable ADL on `begin`. – Yakk - Adam Nevraumont Aug 20 '14 at 23:56

score 9 · Answer 2 · answered Aug 20 '14 at 20:22

9

STL containers have the typedef value_type, so you may use it.

Then you may forbid with static_assert:

template <typename Container>
void foo(const Container& )
{
    static_assert(std::is_same<int, typename Container::value_type>::value, "expect int type");
}

or via SFINAE

template <typename Container>
typename std::enable_if<std::is_same<int, typename Container::value_type>::value>::type
foo(const Container& )
{
}

answered Aug 20 '14 at 20:22

Jarod42

203,559
14
181
302

Could you give an explanation, why/when this is to be favored over a purely template-based solution for the problem? – S.H Aug 20 '14 at 20:25
@S.H: `static_assert` give a better error message and SFINAE disables the non matching template and so is not part of overload (so you may add an other overload for float container for example). – Jarod42 Aug 20 '14 at 20:29

score 4 · Accepted Answer · answered Aug 20 '14 at 20:24

You can simply use Sfinae, like this:

#include <type_traits>
#include <utility>

template <typename Container>
typename std::enable_if< std::is_same< typename Container::value_type, int >::value,
void >::type foo(Container& c) {
  /* code here */
};

Which will be removed from the set of overloads of "foo" if the container does not have a value type that is the same as "int". You can also use other traits, like is_convertible for being more accepting of related types. Calling foo with a container that does not have int as values will be reported by the compiler has having no suitable overload candidates.

If you don't have C++11 support, the things I used above are available in Boost as a C++98/03 alternative.

score 3 · Answer 4 · answered Aug 20 '14 at 20:37

Another solution, using template template parameters

template<template<typename, typename...> class Container, typename... Params>
void foo(Container<int, Params...> const&)
{
  ...
}

This will match vector, list or deque as long the type of the elements in the container is int.

Live demo

score 0 · Answer 5 · answered Aug 20 '14 at 23:01

Assumeing you want an iterable range:

template<class I>
using value_type_t=typename std::iterator_traits<I>::value_type;

Obsolete in C++14:

template<class T>using decay_t=typename std::decay<T>::type;
template<bool b,class T=void>using enable_if_t=typename std::enable_if<b,T>::type;

Then:

namespace adl_details{
  using std::begin;
 template<class C>using iterator_type=decay_t<decltype(begin(std::declval<C>()))>;
}
using adl_details::iterator_type;


template<class C>
enable_if_t<std::is_same<int, value_type_t<iterator_type_t<C>>>::value>
foo(C&& c){
}

has that property.

template for "AnySTLContainer" c++

5 Answers5