Le temps de compilation sizeof_array sans l'aide d'une macro

Essayez les opérations suivantes à partir ici:

template <typename T, size_t N>
char ( &_ArraySizeHelper( T (&array)[N] ))[N];
#define mycountof( array ) (sizeof( _ArraySizeHelper( array ) ))

int testarray[10];
enum { testsize = mycountof(testarray) };

void test() {
    printf("The array count is: %d\n", testsize);
}

Il devrait imprimer: "Le tableau de comptage est de: 10

OriginalL'auteur Adisak

Le mieux je pense est de cette:

template <class T, std::size_t N>
char (&sizeof_array(T (&a)[N]))[N];

//As litb noted in comments, you need this overload to handle array rvalues
//correctly (e.g. when array is a member of a struct returned from function),
//since they won't bind to non-const reference in the overload above.
template <class T, std::size_t N>
char (&sizeof_array(const T (&a)[N]))[N];

qui doit être utilisé avec un autre sizeof:

int main()
{
    int a[10];
    int n = sizeof(sizeof_array(a));
    std::cout << n << std::endl;
}

[MODIFIER]

Venez pour penser à elle, je crois que c'est prouvable impossible de le faire en une seule fonction "-comme l'appellent" en C++03, en dehors de macros, et voici pourquoi.

D'une part, vous avez évidemment besoin de paramètre de modèle de la déduction pour obtenir la taille du tableau (soit directement, soit par sizeof comme vous le faites). Toutefois, le paramètre de modèle déduction est applicable uniquement à des fonctions, et non pas à des classes; c'est à dire que vous pouvez avoir un modèle de paramètre R de type de référence-de-tableau-de-N, où N est un autre paramètre du modèle, mais vous aurez à fournir à la fois R et N au moment de l'appel; si vous voulez en déduire N de R, mais seulement un appel de fonction ne peut le faire.

D'autre part, la seule façon de toute expression impliquant un appel de fonction peut être constante, c'est quand il est à l'intérieur de sizeof. Rien d'autre (par exemple l'accès à un statique ou membre enum sur la valeur de retour de la fonction) nécessite encore l'appel à la fonction se produire, ce qui implique, bien sûr, ce ne sera pas une expression constante.

OriginalL'auteur Pavel Minaev

Ce n'est pas exactement ce que vous cherchez, mais il est proche - un extrait de winnt.h qui comprend une explication de ce que l' #$%^ c'est fait:

//
//RtlpNumberOf is a function that takes a reference to an array of N Ts.
//
//typedef T array_of_T[N];
//typedef array_of_T &reference_to_array_of_T;
//
//RtlpNumberOf returns a pointer to an array of N chars.
//We could return a reference instead of a pointer but older compilers do not accept that.
//
//typedef char array_of_char[N];
//typedef array_of_char *pointer_to_array_of_char;
//
//sizeof(array_of_char) == N
//sizeof(*pointer_to_array_of_char) == N
//
//pointer_to_array_of_char RtlpNumberOf(reference_to_array_of_T);
//
//We never even call RtlpNumberOf, we just take the size of dereferencing its return type.
//We do not even implement RtlpNumberOf, we just decare it.
//
//Attempts to pass pointers instead of arrays to this macro result in compile time errors.
//That is the point.
//
extern "C++" //templates cannot be declared to have 'C' linkage
template <typename T, size_t N>
char (*RtlpNumberOf( UNALIGNED T (&)[N] ))[N];

#define RTL_NUMBER_OF_V2(A) (sizeof(*RtlpNumberOf(A)))

La RTL_NUMBER_OF_V2() la fin de la macro est utilisé dans la plus lisible ARRAYSIZE() macro.

Matthew Wilson "Imparfaite C++" livre a aussi une discussion sur les techniques qui sont utilisées ici.

OriginalL'auteur Michael Burr

Vous ne pouvez pas le résoudre en général, c'est l'une des raisons pour tableau wrappers comme boost tableau (plus de stl, style de comportement, bien sûr).

OriginalL'auteur Georg Fritzsche

Sans C++0x, le plus proche que je puisse obtenir est:

#include <iostream>

template <typename T>
struct count_of_type
{
};


template <typename T, unsigned N>
struct count_of_type<T[N]> 
{
    enum { value = N };
};

template <typename T, unsigned N>
unsigned count_of ( const T (&) [N] )
{
    return N;
};


int main ()
{
    std::cout << count_of_type<int[20]>::value << std::endl;
    std::cout << count_of_type<char[42]>::value << std::endl;

    //std::cout << count_of_type<char*>::value << std::endl; //compile error

    int foo[1234];

    std::cout << count_of(foo) << std::endl;

    const char* bar = "wibble";

    //std::cout << count_of( bar ) << std::endl; //compile error

    enum E1 { N = count_of_type<int[1234]>::value } ;

    return 0;
}

qui vous donne une fonction, vous pouvez transmettre la variable, ou d'un modèle, vous pouvez passer le type de trop. Vous ne pouvez pas utiliser la fonction pour une compilation constante de temps, mais la plupart des cas vous connaissez le type, même si seulement en tant que paramètre du modèle.

OriginalL'auteur Pete Kirkham