sizeof o zmiennej liczbie argumentów szablonu (suma wszystkich elementów sizeof)

Question

uwzględnieniem następujących funkcji:

template<typename... List> 
inline unsigned int myFunction(const List&... list) 
{ 
    return /* SOMETHING */; 
} 

Co jest najbardziej prosta rzecz umieścić zamiast /* SOMETHING */ aby powrócić sumę sizeof wszystkie argumenty?

Na przykład myFunction(int, char, double) = 4+1+8 = 13

Answer 1

unsigned myFunction() {return 0;} 

template <typename Head, typename... Tail> 
unsigned myFunction(const Head & head, const Tail &... tail) { 
    return sizeof head + myFunction(tail...); 
} 

Answer 2

oparciu off this comment i następujące komentarze na pytanie, można użyć tego (uwaga: całkowicie niesprawdzone)

std::initializer_list<std::size_t> sizeList = {sizeof(List)...}; //sizeList should be std::initializer_list, according to the comments I linked to 
return std::accumulate(sizeList.begin(), sizeList.end(), 0); 

Answer 3

Właśnie stwierdził, że:

template<typename... List> 
inline unsigned int myFunction(const List&... list) 
{ 
    return sizeof(std::make_tuple(list...)); 
} 

Ale:

1) Czy mam gwarancję, że wynik będzie zawsze taki sam we wszystkich kompilatorach?

2) Czy make_tuple będzie robił i napełniał podczas kompilacji?

Answer 4

Dwa lata późno jednak alternatywne rozwiązanie gwarantuje być obliczane przez kompilator (jeśli nie przeszkadza innej składni):

template < typename ... Types > 
struct SizeOf; 

template < typename TFirst > 
struct SizeOf <TFirst> 
{ 
    static const auto Value = (sizeof(TFirst)); 
}; 

template < typename TFirst, typename ... TRemaining > 
struct SizeOf < TFirst, TRemaining ... > 
{ 
    static const auto Value = (sizeof(TFirst) + SizeOf<TRemaining...>::Value); 
}; 

Używany jako const int size = SizeOf<int, char, double>::Value; // 4 + 1 + 8 = 13

Answer 5

w C++ 17, używać krotny wyrażenie:

template<typename... List> 
inline constexpr unsigned int myFunction(const List&... list) 
{ 
    return (0 + ... + sizeof(List)); 
} 

Answer 6

Oto sposób szablon:

#include <iostream> 

template<typename T, typename ...Ts> 
class PPackSizeOf 
{ 
    public: 
    static const unsigned int size = sizeof(T) + PPackSizeOf<Ts...>::size; 
}; 


template<typename T> 
class PPackSizeOf<T> 
{ 
    public: 
    static const unsigned int size = sizeof(T); 
}; 

template<typename ...Ts> 
class FixedSizeBlock 
{ 
    private: 
     char block[PPackSizeOf<Ts...>::size]; 
    public: 

}; 

int main() 
{ 
    FixedSizeBlock<char,long> b; 
    std::cout << sizeof(b) << std::endl; 
    return 0; 
}