So erhalten Sie Größen von Arrays in einer Schleife

Question

Ich bin mehrere Arrays in der Reihenfolge und eine Art von Klassifizierung ausrichten. Ich habe ein Array erstellt, das andere Arrays enthält, um die Operationen zu vereinfachen, die ich ausführen möchte.

Leider ist mein Programm abgestürzt, als ich es lief und ich fuhr fort, es zu debuggen, um schließlich zu erkennen, dass der sizeof Operator mir Größen von Zeigern und nicht Arrays innerhalb der Schleife gibt. So griff ich auf die umständliche Lösung und mein Programm zurück hat funktioniert.

Wie kann ich diese umständliche Methode vermeiden? Ich möchte in einer Schleife rechnen!

#include <iostream> 
#include <string> 

#define ARRSIZE(X) sizeof(X)/sizeof(*X) 

int classify(const char *asset, const char ***T, size_t T_size, size_t *index); 

int main(void) 
{ 
    const char *names[] = { "book","resources","vehicles","buildings" }; 

    const char *books[] = { "A","B","C","D" }; 
    const char *resources[] = { "E","F","G" }; 
    const char *vehicles[] = { "H","I","J","K","L","M" }; 
    const char *buildings[] = { "N","O","P","Q","R","S","T","U","V" }; 

    const char **T[] = { books,resources,vehicles,buildings }; 

    size_t T_size = sizeof(T)/sizeof(*T); 
    size_t n, *index = new size_t[T_size]; 

    /* This will yeild the size of pointers not arrays... 
     for (n = 0; n < T_size; n++) { 
      index[n] = ARRSIZE(T[n]); 
     } 
    */ 

    /* Cumbersome solution */ 
    index[0] = ARRSIZE(books); 
    index[1] = ARRSIZE(resources); 
    index[2] = ARRSIZE(vehicles); 
    index[3] = ARRSIZE(buildings); 

    const char asset[] = "L"; 

    int i = classify(asset, T, T_size, index); 

    if (i < 0) { 
     printf("asset is alien !!!\n"); 
    } 
    else { 
     printf("asset ---> %s\n", names[i]); 
    } 

    delete index; 
    return 0; 
} 

int classify(const char *asset, const char ***T, size_t T_size, size_t *index) 
{ 
    size_t x, y; 

    for (x = 0; x < T_size; x++) { 
     for (y = 0; y < index[x]; y++) { 
      if (strcmp(asset, T[x][y]) == 0) { 
       return x; 
      } 
     } 
    } 
    return -1; 
} 

Answer 1

Wie Sie mit <string> und <iostream> Ich gehe davon aus, dass die Frage über C++ und nicht C. all diese Komplikation zu vermeiden, einfach Behälter verwenden. ZB:

#include <vector> 

std::vector<int> vect = std::vector<int>(3,0); 
std::cout << vect.size() << std::endl;   // prints 3 

Answer 2

Eine Lösung, wenn Sie in C-Codierung ist das Array mit einem speziellen Punkt zu beenden, wie NULL

const char *books[] = { "A","B","C","D", NULL }; 

size_t size(const char *arr[]) 
{ 
    const char **p = arr; 

    while (*p) 
    { 
     p++; 
    } 

    return p - arr; 
} 

Answer 3

Sie die Größe des Array Explizit angeben:

size_t n, index[] = {ARRSIZE(books), ARRSIZE(resources), ARRSIZE(vehicles), ARRSIZE(vehicles)}; 

oder wenn Sie doppelte Eingabe vermeiden möchten, können Sie X-Macros alles ausrollen:

#define TBL  \ 
    X(books)  \ 
    X(resources) \ 
    X(vehicles) \ 
    X(buildings) 

    const char **T[] = { 
#define X(x) x, 
TBL 
    }; 
#undef X 

    size_t n, index[] = { 
#define X(x) ARRSIZE(x), 
TBL 
}; 

, die das gleiche produziert. Siehe Running Demo.