Eure Wünsche an Sprachfeatures für den nächsten Standard (nach C++11)

GorbGorb

Nexus schrieb:

template <typename Iterator>
void Func(Iterator first, Iterator last)
{
    FuncImpl(first, last, typename std::iterator_traits<Iterator>::iterator_category());
}

template <typename Iterator>
void FuncImpl(Iterator first, Iterator last, std::random_access_iterator_tag);

template <typename Iterator>
void FuncImpl(Iterator first, Iterator last, std::bidirectional_iterator_tag);

Ich weiß, dass es sowas gibt, aber kommt nur mir sowas extrem umständlich vor? Ich meine, was man im Grunde will, ist, in Abhängigkeit von einem bestimmten Wert unterschiedlichen code auszuführen. In jeder mir bekannten Programmiersprache (zugegeben, sind nicht viele) funktioniert sowas mit einem if. Nur in c++ tmp muss man dafür auf irgendwelche Hilfskonstrukte zurückgreifen, die Funktionsüberladung und evtl. sogar SFINAE verwenden, um sowas zu erreichen.
Ich bin mir sehr sicher, dass code mit einem static_if deutlich lesbarer würde.

otze

Concepts. Dann bin ich glücklich. Ehrlich, einiges von dem was C++11 bringt, brauch ich gar nicht. Variadic templates werden sicherlich keinen großen impact haben, also abseits von Boost und ner handvoll anderer Bibliotheken. Concepts wären der Bringer gewesen...naja,vielleicht beim nächsten mal.

Dravere

Nexus schrieb:

template <typename Iterator>
void Func(Iterator first, Iterator last)
{
    FuncImpl(first, last, typename std::iterator_traits<Iterator>::iterator_category());
}

template <typename Iterator>
void FuncImpl(Iterator first, Iterator last, std::random_access_iterator_tag);

template <typename Iterator>
void FuncImpl(Iterator first, Iterator last, std::bidirectional_iterator_tag);

Frage am Rande, weiss das vielleicht einer? Darf der Kompiler hier den dritten Funktionsparameter wegoptimieren? Er wird ja nur dazu verwendet, um herauszufinden, welche Funktion aufgerufen wird. Somit ist der Parameter nur zur Kompilezeit relevant.

Oder wäre es vielleicht klüger dies wie folgt zu schreiben:

template<typename IteratorCategory>
struct FuncImpl
{
};

template<>
struct FuncImpl<std::random_access_iterator_tag>
{
  template<typename Iterator>
  static void Call(Iterator first, Iterator last);
};

template<>
struct FuncImpl<std::bidirectional_iterator_tag>
{
  template<typename Iterator>
  static void Call(Iterator first, Iterator last);
};

template <typename Iterator>
void Func(Iterator first, Iterator last)
{
    FuncImpl<typename std::iterator_traits<Iterator>::iterator_category>.call(first, last);
}

Grüssli

GorbGorb

otze schrieb:

Concepts. Dann bin ich glücklich. Ehrlich, einiges von dem was C++11 bringt, brauch ich gar nicht. Variadic templates werden sicherlich keinen großen impact haben, also abseits von Boost und ner handvoll anderer Bibliotheken. Concepts wären der Bringer gewesen...naja,vielleicht beim nächsten mal.

Was ich an variadic templates so genial finde, ist, dass man damit Beziehungen zwischen Objekten/Modulen abstrahieren kann, also die Softwarearchitektur modellieren kann.

Auch noch was zum Thema templates: Ich fände es ganz nett, wenn man bestimmte Restriktionen etwas lockern könnte:
- warum muss eine template Spezialiserung im namespace scope stehen (vc++ kann das z.B. auch in einer Klasse)
- warum können lokale Klassen in Funktionen keine template member haben?

314159265358979

GorbGorb schrieb:

- warum können lokale Klassen in Funktionen keine template member haben?

Können sie doch. Glaub ich.

krümelkacker

Nexus schrieb:

template <typename Iterator>
void Func(Iterator first, Iterator last)
{
    FuncImpl(first, last, typename std::iterator_traits<Iterator>::iterator_category());
}

template <typename Iterator>
void FuncImpl(Iterator first, Iterator last, std::random_access_iterator_tag);

template <typename Iterator>
void FuncImpl(Iterator first, Iterator last, std::bidirectional_iterator_tag);

Du musst die FuncImpl-Teampltes über der Definition von Func deklarieren. So, klappt das nur mit Microsoft's Compiler, weil der es nicht so genau nimmt mit dem Name-Lookup.

GorbGorb

314159265358979 schrieb:

GorbGorb schrieb:

- warum können lokale Klassen in Funktionen keine template member haben?

Können sie doch. Glaub ich.

Kriegst du das zum Laufen?

int main()
{
	class X
	{
	public:
		template< class Type >
		void func()
		{

		}
	};
}

314159265358979

GorbGorb schrieb:

int main()
{
	class X
	{
	public:
		template< class Type >
		void func()
		{

		}
	};
}

Ein Kommunikationsproblem also. Ich dachte, du meinst lokale Klassen, die in Funktionen stehen und Template Parameter haben.

Geht aber offenbar auch nicht. Da war doch mal was vonwegen lösen der Beschränkungen in C++11?

GorbGorb

Ich glaub mit c++11 ist es möglich, einen lokalen Typen als template parameter zu verwenden (das hast du vielleicht gemeint).
Mit den neuen Möglichkeiten bei tmp ist so eine Art template-Funktor aber durchaus manchmal sinnvoll, daher fände ich es gut wenn man sowas lokal dort erstellen kann, wo man es braucht:

class Functor
{
public:
    template< class Type >
    void operator()()
    {
    }
};

Dravere

@GorbGorb,
Funktionslokale Klassen wurden ja eigentlich nun durch Lambdas ersetzt.
Darf ich nach einem Beispiel fragen, wozu du ein Funktionstemplate in einer funktionslokalen Klasse benötigst?

Grüssli

GorbGorb

Dravere schrieb:

@GorbGorb,
Funktionslokale Klassen wurden ja eigentlich nun durch Lambdas ersetzt.
Darf ich nach einem Beispiel fragen, wozu du ein Funktionstemplate in einer funktionslokalen Klasse benötigst?

Grüssli

Zum Bleistift für sowas:

template< class ... >
class type_set;

template<>
class type_set<>
{
public:
    template< class TypeFunctor >
    static void for_each( TypeFunctor && )
    {
    }
};
template< class Head , class ...Tail >
class type_set< Head , Tail... >
{
public:
    template< class TypeFunctor >
    static void for_each( TypeFunctor &&Functor )
    {
        Functor.operator()< Head >();
        type_set< Tail... >::for_each( Functor );
    }
};

Hab ich schon ein paar Mal ganz nützlich gefunden. Ein anderes Anwendungsbeispiel wäre eine multitype queue (also eine queue in der man beliebige Typen auf der einen Seite reinschiebt, speichert und dann am anderen Ende mit so einem Funktor wieder rausholt), das hab ich aber noch nicht umgesetzt.
Will man das benutzen braucht man eben einen Typen mit Funktionstemplate, und da der Funktor sehr häufig nur zu einer Funktion gehört würde ich ihn auch gerne in ihr definieren. Es geht mir also nur um schöneren code.