ich kompiliere hier gerade folgenden code mit maximaler Optimierung:

#include <cstdio>
#include <tuple>

struct something {
	unsigned int get_size() {
		return 4;
	}
};

struct something_else {
	unsigned int get_size() {
		return 5;
	}
};

template< unsigned int... Indices >
struct index_list
{
};

template< typename... Args, unsigned int... Indices >
void test_func(index_list<Indices...>, Args && ... args )
{
	std::tuple< Args... > tuple(args...);

	const unsigned int array[] = {
		std::get<Indices>(tuple).get_size()...
	};

	for (unsigned int i = 0; i < sizeof...(Indices); ++i) {
		std::printf("%u", array[i]);
	}
}

int main(int argc, char* argv[])
{
	test_func( index_list<0, 1, 2, 3>(), something(), something_else(), something(), something_else() );

	return 0;
}

Was mich wundert ist, dass der Compiler (Visual C++ 2013 ctp) hier nicht auf die Idee gekommen ist, dass das Array mit Werten gefüllt wurde, die zur Compile-Zeit bekannt sind und es somit komplett entfernt und einfach die Konstanten verwendet:

mov	DWORD PTR _array$1[ebp], 4
	mov	DWORD PTR _array$1[ebp+4], 5
	mov	DWORD PTR _array$1[ebp+8], 4
	mov	DWORD PTR _array$1[ebp+12], 5

; ...
$LL5@main:

; 31   : std::printf("%u", array[i]);
; Einfache Schleife hier, die auf das array zugreift
	push	DWORD PTR _array$1[ebp+esi*4]
	push	OFFSET ??_C@_02GMHACPFF@?$CFu?$AA@
	call	edi
	inc	esi
	add	esp, 8
	cmp	esi, 4
	jb	SHORT $LL5@main

Darf der Compiler das nicht tun, weil ich gerade irgendeinen Nebeneffekt übersehe?
Das Beispiel mag gerade blöd aussehen, aber genau so ein Konstrukt erhalte ich in meiner Skript-Binding-Bibliothek.
Ich könnte den Code so gestalten, dass er davon ausgeht, dass die Zahlen konstant sind (also static const member...), aber dann funktioniert das nicht mehr für Fälle wo das nicht so ist. Ich hätte gehofft, dass der Compiler eben den Standardfall so optimiert

Viele Grüße

template< typename... Args, unsigned int... Indices >
void test_func(index_list<Indices...>, Args && ... args )
{
    std::tuple< Args... > tuple{ std::forward<Args>(args)... };

	bool _[] = { std::cout << std::get<Indices>(tuple).get_size()... };
}

das std::forward da bringt leider MSVC++2013 zum Absturz, daher habe ich es in meinem Beispiel wieder herausnehmen müssen.

Was zum...!? Ein einfaches forward ? VC++*, du $&@]? !

Ich hätte gerne vermieden, dass ich an allen Stellen, an denen ich die Elemente des Arrays brauche, wieder irgendein Hilfs-Template expandieren muss, so wie Du es vorschlägst.

Das ist doch kein Template. Nur ein kleiner Trick.

Ich brauche an bestimmten Stellen halt die Summe der Funktionswerte von 0 bis X, oder die Summe aller Werte usw

Und hier kommt die brillante Welt der Template-Metaprogrammierung.

~* Für alle Leute, die es noch nicht kapiert haben: Ich flame permanent gegen den Compiler, nicht gegen die IDE..~