class C
{
public:
  C(int i, long l);

  template <class Iter>
  C(Iter first, Iter last);
};

Nun möchte ich aber, wenn zwei int als Parameter übergeben werden, der ersten Konstruktor aufrufen lassen. Wie bekomm ich das ohne große Codeduplizierung und ohne große Abfragen im zweiten Ctor hin?

Wenn zwei int übergeben werden sollte der 1. Konstruktor aufgerufen werden und ein int in long gecastet werden, sofern der Konstruktor nicht explicit ist

Nein, dass geht nicht.

@pumuckl,
Mach doch einen zusätzlichen Konstruktor, welcher zwei int Typen entgegen nimmt.

Grüssli

Hm. Ginge das nicht mit boost::enable_if?

hatte ich mit enable_if nicht immer den rückgabetyp maniputtgemacht? sowas hat der konstruktor leider nicht. ich könnte ein drittes pseudoargument puttmachen. naja, irgendwie nicht lecker.

class C
{
public:
  C(int i, long l){}

  template <class Iter>
  C(Iter first, Iter last){}
};

int main()
{
    int a, b;
    C c(a,b); //funktioniert
}

Oder verstehe ich das Problem falsch

Oder verstehe ich das Problem falsch

Ja oder du merkst nicht, dass es die falsche Version aufruft. Es ruft nämlich die Templateversion auf. Mach mal das:

#include <iostream>

class C
{
public:
  C(int i, long l)
  {
    std::cout << "int i, long l" << std::endl;
  }

  template <class Iter>
  C(Iter first, Iter last)
  {
    std::cout << "Iter first, Iter last" << std::endl;
  }
};

int main()
{
  int a, b;
  C c(a,b); // Gibt garantiert "Iter first, Iter last" aus.
  // Und das will er ja gerade nicht ;)
}

@hustbaer,
Und wie stellst du dir das vor?
Es gibt nicht mal eine eindeutige Möglichkeit einen Iterator zu erkennen ...

Ich bin immer noch für einen Konstruktor mit int, int . Um doppelten Intialisierungslisten Code zu verhindern, kann man die Member intern in ein struct verpacken. Zudem kann man eine private init Funktion verwenden. Also kurz skizziert:

class C
{
private:
  struct
  {
    int m_i;
    long m_l;

    Members(int i, long l)
      : m_i(i)
      , m_l(l)
    {
    }
  }
  m_members;

public:
  C(int i, long l)
    : m_members(i, l)
  {
    init();
  }

  C(int i, int b)
    : m_members(i, b)
  {
    init();
  }

  template <class Iter>
  C(Iter first, Iter last)
    : m_members(0, 0)
  {
    // whatever ...
  }

private:
  void init()
  {
    // whatever ...
  }
};

Kommt natürlich ganz darauf an, wie die Klasse intern aussieht.

Grüssli

Hm. Ginge das nicht mit boost::enable_if?

Ja, an SFINAE hatte ich auch gedacht. Es fehlt nur noch eine Abfrage, ob "Iter" wirklich ein Iterator ist.

class A
{
public:
  A(int,long);

  template<typename Iter>
  A(Iter beg, Iter end,
    typename boost::enable_if<is_iterator<Iter>,char>::type=0)
  {
    //...
  }
};

Leider fällt mir spontan nichts für is_iterator ein. Mit Concepts wär das einfach gewesen (requires InputIterator<Iter> ).

Gruß,
SP

Gruß,
SP

template<typename T>
struct make
{
  static T& lvalue();
  static T&& rvalue();
};

class A
{
public:
  A(int,long);

  template< typename Iter, // Dereferenzieren möglich?
            typename Test = decltype(*make<Iter>::rvalue()) >
  //                                 ^
  A(Iter beg, Iter end)
  {
    // ...
  }
};

müsste nach meinem Verständnis in C++0x funktionieren. Diese oder ähnliche Varianten habe ich aber unter g++ 4.3 mit -std=c++0x nicht zum Laufen bekommen, da der Compiler es vorzieht, eine Fehlermeldung auszuspucken, statt das Template einfach zu ignorieren falls das Einsetzen schiefgeht. Ihr könnt ja mal mit g++ 4.4 testen -- der soll, was SFINAE angeht, gnädiger sein.

Mit diesen "erweiterten SFINAE Möglichkeiten" wären wir zumindest nicht ganz verloren ... so ohne Concepts. Die ganzen syntaktischen Typ-Bedingungen sollten per decltype testbar sein.

Gruß,
SP

template<typename Iter>
  A(Iter beg, Iter end,
    typename boost::enable_if<is_iterator<Iter>,char>::type=0)

Guter Ansatz, ich werds mal mit mit boost::disable_if<is_integral<Iter>,char>::type = 0 versuchen wenn ich das nächstemal dran sitze

Guter Ansatz, ich werds mal mit mit boost::disable_if<is_integral<Iter>,char>::type = 0 versuchen wenn ich das nächstemal dran sitze

So geht's natürlich auch!
Oder vielleicht sogar mit is_convertible<Iter,int> und is_convertible<Iter,long> .

Ich habe übrigends vorhin gcc-4.4.1 kompiliert, um das C++0x-Beispiel mit decltype zu testen: Es funzt.

Gruß,
SP

War leider nichts - er versucht krampfhaft die Iteratorversion aufzurufen bei zwei ints und stolpert über enable_if::type

Kein Wunder, es ist ja auch kein Substitutionsfehler. Die Substitution klappt einwandfrei. Grundsätzlich müsstest du sowas machen:

template<typename IterT>
C(IterT, IterT, typename std::iterator_traits<IterT>::iterator_category category = typename std::iterator_traits<IterT>::iterator_category())
{
}

Nur dass es problematisch ist, weil es unter MSVC zum Beispiel auch Spezialisierungen für std::iterator_traits für int , double , float , long , short , usw. gibt. Daher funktioniert dies auch nicht ... Es gibt eben keine Möglichkeit einen Iterator zu erkennen.

Das einzige was du machen könntest, sind gewisse Typen explizit auszuschliessen. Ehm, das müsste dann so gehen:

struct EmptyType { };

temlate<typename T>
struct ExcludedTraits
{
  typename EmptyType Allowed;
};

template<>
struct ExcludedTraits<int>
{
  // int ausschliessen.
};

class C
{
public:
  C(int, long) { std::cout << "funzt" << std::endl; }

  template<typename IterT>
  C(IterT, IterT, 
     typename ExcludedTraits<IterT>::Allowed = typename ExcludedTraits<IterT>::Allowed())
  {
    std::cout << "meep" << std::endl;
  }
};

int main()
{
  int a = 0;
  int b = 0;

  C c(a, b); // sollte gehen ...
}

Vielleicht kann man es über Typlisten noch ein wenig vereinfachen.
Aber ob das viel einfacher ist als einfach einen zusätzlichen Konstruktor?

Grüssli

War leider nichts - er versucht krampfhaft die Iteratorversion aufzurufen bei zwei ints und stolpert über enable_if::type

Wie wär's mit etwas Code? Ich habe vorhin das hier probiert:

#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_integral.hpp>

void foo(int, long)
{
	std::cout << "1\n";
}

template<typename Iter>
void foo(Iter beg, Iter end,
	typename boost::disable_if<boost::is_integral<Iter>,char>::type=0)
{
	std::cout << "2\n";
}

int main()
{
	foo(23,42);
}

und es macht genau das, was es soll ("1" ausgeben).

Gruß,
SP

Gruß
Don06

Ich ziehe mein vorheriges Posting zurück ... peinlich, peinlich ...

Grüssli

Mein Ansatz bisher:

template <class T>
class MyContainer /*: boost::equality_comparable<MyContainer<T> >*/
{
  template <class Iter>
  struct DisableInt
  {
    typedef typename boost::disable_if<
      boost::is_integral<Iter>, char
    >::type type;
  };

public:

  MyContainer();
  explicit MyContainer( size_type n, const_value_type& value= T());
  template <class InputIterator >
  MyContainer(InputIterator first, InputIterator last, 
         typename DisableInt<InputIterator>::type = 0);
};

Beim Compilieren gibts dann entsprechend eine Fehlermeldung:

c:\development\projects\lib_pumu\src\pumu\container\mycontainer.hpp(26) : error C2039: 'type' : is not a member of 'boost::disable_if<Cond,T>'
1>        with
1>        [
1>            Cond=boost::is_integral<int>,
1>            T=char
1>        ]
1>        c:\development\projects\lib_pumu\test\pumu\container\testmycontainer.cpp(81) : see reference to class template instantiation 'pumu::container::MyContainer<T>::DisableInt<Iter>' being compiled
1>        with
1>        [
1>            T=int,
1>            Iter=int
1>        ]

Grüssli

template <class Iter>
struct DisableInt : public boost::disable_if<boost::is_integral<Iter>, char>
{};

Nur dass es problematisch ist, weil es unter MSVC zum Beispiel auch Spezialisierungen für std::iterator_traits für int , double , float , long , short , usw. gibt. Daher funktioniert dies auch nicht ... Es gibt eben keine Möglichkeit einen Iterator zu erkennen.

Das ist komisch. Weisst du wozu es diese Spezialisierungen gibt?

Aber mal davon abgesehen... könnte man sich nicht zu nutze machen dass in dem Fall Iter und std::iterator_traits<Iter>::value_type der selbe Typ sind?

Ich muss sagen, als ich enable_if vorgeschlagen habe, bin ich einfach davon ausgegangen, dass es recht einfach möglich sein muss is_iterator zu implementieren, da es ja std::iterator_traits gibt.

Irgendwie ziemlich doof dass es doch nicht so einfach ist

Irgendwie ziemlich doof dass es doch nicht so einfach ist

Ich schätze mal wenns so einfach wäre gäbs bei boost auch ein is_iterator oder ähnliches. Es gibt in der Mailing-List schon eine längere Diskussion zu dem Thema:

http://lists.boost.org/Archives/boost/2004/08/70530.php

Das ist komisch. Weisst du wozu es diese Spezialisierungen gibt?

Nicht die Bohne einer Ahnung! Es steht nicht mal hier etwas:
http://msdn.microsoft.com/en-us/library/zdxb97eh.aspx

Ich weiss es selber nur, weil ich mal etwas über std::iterator_traits lösen wollte und dabei voll auf die Schnauze gefallen bin. Vor allem habe ich zuerst ziemlich lange gesucht, bis ich gemerkt habe, dass da zusätzliche Spezialisierungen vorhanden sind. Ich wäre niemals auf diese Idee gekommen

Hey ... moment mal ... würde sowas nicht gehen?

template<typename CategoryT>
struct isValidIteratorCategory
{
  enum ( value = 0 };
};

template<>
struct isValidIteratorCategory<std::input_iterator_tag>
{
  enum { value = 1; };
};

template<>
struct isValidIteratorCategory<std::output_iterator_tag>
{
  enum { value = 1; };
};

template<>
struct isValidIteratorCategory<std::forward_iterator_tag>
{
  enum { value = 1; };
};

template<>
struct isValidIteratorCategory<std::bidirectional_iterator_tag>
{
  enum { value = 1; };
};

template<>
struct isValidIteratorCategory<std::random_access_iterator_tag>
{
  enum { value = 1; };
};

template<typename IterT>
struct IsIterator
{
  enum { value = isValidIteratorCategory<typename std::iterator_traits<IterT>::iterator_category>::value };
};

template<typename T>
struct IsIterator<T*>
{
  enum { value = 1; };
};

template<typename T>
struct IsIterator<T const*>
{
  enum { value = 1; }
};

Oder überseh ich etwas?

Grüssli

Oder überseh ich etwas?

class Alien {};
int main()
{
    cout << IsIterator<Alien>::value;
}

Das ist dann möglicherweise der Grund, weshalb Spezialisierungen für int&co. eingeführt werden, um nicht schon iterator_traits<int>::iterator_category auszusteigen, sondern ggf. das Ergebnis per sfinae zu verwerten.

vielleicht so

typedef char no;
typedef no yes[2];
no& tag_test(...);
template <typename T> yes& tag_test(const T&, iterator_traits<T>::iterator_category*=0);
template <typename T>
struct has_tag : mpl::bool_<sizeof(tag_test(*(T*)0))==sizeof(yes)> {};

typedef mpl::vector<input_iterator_tag,output_iterator_tag,forward_iterator_tag,random_access_iterator_tag> valid_tags;
template <typename T, bool = has_tag<T>::value>
struct is_iterator : mpl::contains<valid_tags,T> {};
template <typename T>
struct is_iterator< T, false> : mpl::bool_<false> {};

template <class T>
struct DisableInt : public boost::disable_if<boost::is_integral<T>, T>{};

void foo(int i, short l)
{
   cout << "integral" << endl;
}

template<class I>
void foo(I first, typename DisableInt<I>::type last)
{
  cout << "iterator" << endl;
}

int main()
{
   int a[] = {1, 2, 3, 4, 5};
   std::vector<int> vec(a, a+5);

   foo(3, 6); //integral
   foo(a, a+5); //iterator
   foo(vec.begin(), vec.end()); //iterator
}

Gibts irgendwelche Fallen in die ich da tappen könnte oder ist das ok?