void insert(iterator __position, size_type __n, const value_type& __x)
{  
  list __tmp(__n, __x, _M_get_Node_allocator());
  splice(__position, __tmp);
}

template<typename _InputIterator>
void insert(iterator __position, _InputIterator __first,
	       _InputIterator __last)
{
  list __tmp(__first, __last, _M_get_Node_allocator());
  splice(__position, __tmp);
}

und der compiler ist durchaus schlau genug die erste variante aufzurufen, auch wenn value_type = int ist und __x von einem anderen integralen typ konvertiert wird sowie __n nicht explizit nach size_type gecastet wurde.

hier mein beispiel:

#include <cstdlib>
#include <list>

using namespace std;

struct S{
  int x;
};

template <typename T>
class C{
  public:
    template <typename T2>
    void foo(T2 i){
      i.x = 0;
    }

    void foo(size_t i){
    }

};

int main(){
  for(int i = 0, j = 0; true; ++i, ++j);

  C<int> c;
  c.foo((size_t)0); //funktioniert
  c.foo(0); //funktioniert nicht, versucht template-fkt. zu verwenden

  list<int> l;
  l.insert(l.end(), 5, 5); //funktioniert
  l.insert(l.end(), (int)5, (size_t)5); //funktioniert
  l.insert(l.end(), (long long)5, (long long)5); //funktioniert
}

edit: problem gelöst. tiefer im code der STL sind überladungen für alle 13 integer typen versteckt

template<typename _Tp>
struct __is_integer
{
  enum { __value = 0 };
  typedef __false_type __type;
};

// Thirteen specializations (yes there are eleven standard integer
// types; 'long long' and 'unsigned long long' are supported as
// extensions)
template<>
struct __is_integer<bool>
{
  enum { __value = 1 };
  typedef __true_type __type;
};
// usw...

und den __type nutzt man dann als übergabe-parameter um die passende überladung der funktion aufzurufen.

So?

bool
unsigned char
signed char
unsigned wchar_t
signed wchar_t
unsigned short
signed short
unsigned int
signed int
unsigned long
signed long
unsigned long long
signed long long

guckst du INCLUDEDIR/bits/cpp_type_traits.h falls du einen GCC zur hand hast.

Interessiert mich gerade, wie man auf dreizehn kommt...

So?

bool
unsigned char
signed char
unsigned wchar_t
signed wchar_t
unsigned short
signed short
unsigned int
signed int
unsigned long
signed long
unsigned long long
signed long long

fast. wchar_t kennt keine signed/unsigned-Zusätze (welche Variante zutrifft, hängt vom Compiler ab). Aber du hast auch char als eigenständigen Typ vergessen.

Aber du hast auch char als eigenständigen Typ vergessen.

Danke für die Erklärung; ich wusste nicht, dass char in drei Variationen vorkommt. Ich dachte einfach, es sei systemabhängig, ob er in seiner Standardform signed oder unsigned ist.

camper schrieb:

Aber du hast auch char als eigenständigen Typ vergessen.

Danke für die Erklärung; ich wusste nicht, dass char in drei Variationen vorkommt. Ich dachte einfach, es sei systemabhängig, ob er in seiner Standardform signed oder unsigned ist.

Es ist system- und compilerabhängig, ob char vorzeichenbehaftet ist oder nicht, das ist richtig. Trotzdem sind char und der entsprechend qualifizierte un/signed char zwei verschiedene Typen. In der Hinsicht unterscheidet sich un/signed char von den anderen Typen, wo die signed-qualifikation weggelassen werden kann.