Vraag De grootte van een String-array in C ++ vinden


Dus ik heb een reeks snaren. Hier is een voorbeeld:

string array[] = {"Example", "Example2", "Example3"};

Is er een manier om het aantal elementen in een array zoals hierboven te vinden? Ik kan deze methode niet gebruiken:

int numberofelements = sizeof(array)/sizeof(array[0]);

Dit komt omdat de grootte van de elementen varieert. Is er een andere manier?


16
2018-01-13 22:29


oorsprong


antwoorden:


Gezien je reeks snaren, kun je dit zeker gebruiken sizeof(array)/sizeof(array[0]) om zijn grootte te krijgen en het volgende programma werkt prima:

int main()
{
    std::string array[] = { "S1", "S2", "S3" };
    std::cout << "A number of elements in array is: "
              << sizeof(array)/sizeof(array[0]) << '\n';
    foo(array);
}

Het is niet duidelijk wat je bedoelt als je zegt dat de grootte van elementen varieert. De grootte van de elementen van elke array is altijd bekend op compiler-time, geen uitzonderingen.

Er zijn echter situaties waarin het bovenstaande niet werkt. Bekijk het volgende voorbeeld:

void foo(std::string array[])
{
    std::cout << "A number of elements in array is: "
              << sizeof(array)/sizeof(array[0]) << '\n';
}

De bovenstaande code is gedoemd te mislukken. Het lijkt misschien een beetje raar, maar de reden hiervoor is eigenlijk heel simpel - dit wordt array-ontbinding genoemd. Dit betekent dat elke keer dat u een array doorgeeft aan een functie, het type ervan automatisch vervaagt tot dat van een aanwijzer. Dus de bovenstaande functie is in feite een equivalent hiervan:

void foo(std::string *array)
{
}

En als in het eerste voorbeeld de sizeof operator retourneert de totale grootte van een array, in het tweede voorbeeld wordt de grootte van een aanwijzer naar die array geretourneerd, wat een heel ander ding is.

Er zijn meestal twee manieren waarop mensen het aanpakken. De eerste is om een ​​speciaal "laatste" element van de array toe te voegen, zodat de applicatie de array kan doorkruisen totdat deze het laatste element ziet en de lengte van de array berekent. Letterlijke tekenreeksen zijn daar het perfecte voorbeeld van - elke letterlijke regel eindigt met '\ 0' en u kunt altijd de lengte ervan berekenen. Hier is een voorbeeld:

static void foo(const std::string *array)
{
    size_t i = 0;
    while (!array[i].empty())
        ++i;
    std::cout << "Array length is: " << i << std::endl;
}

Het nadeel is natuurlijk een noodzaak om de array te doorkruisen om de lengte ervan te bepalen. De tweede manier om altijd de lengte van de array bij te houden, bijvoorbeeld:

static void foo(const std::string *array, size_t length)
{
    // ...
}

void bar()
{
    std::string array[] = { "S1", "S2", "S3" };
    foo(array, sizeof(array)/sizeof(array[0]));
}

In C ++ kunt u een sjabloon gebruiken om de lengte van een array af te trekken, bijvoorbeeld:

template <size_t array_length>
static void foo(const std::string (&array)[array_length])
{
    std::cout << "A number of elements in template array is: "
              << array_length << '\n';
}

Al het bovenstaande is van toepassing op eenvoudige arrays die zijn ingebouwd in de taal. C ++, aan de andere kant, biedt een rijke set van containers van een hoger niveau die u veel flexibiliteit bieden. U zou dus kunnen overwegen om een ​​van de containers te gebruiken die voor u beschikbaar zijn als onderdeel van C ++ Standard Library. Voor een lijst met standaardcontainers, zie - http://en.cppreference.com/w/cpp/container

Hoop dat het helpt. Succes!


25
2018-01-13 23:20



U kunt een sjabloonfunctie gebruiken om dat te bereiken:

#include<cstdlib>

template<class T, std::size_t n>
constexpr std::size_t size(T (&)[n])
{ return n; }

En zoals Luchian Grigore al zei, zou je STL-containers moeten gebruiken. std :: array als u gelijkwaardig wilt zijn aan de statische C-array.


7
2018-01-13 22:36



Er is een stand-by-functie in stdlib bibliotheek:

#include <stdlib.h>
static const char * const strings[] = {"str1", "str2", "str3"};
const int stringCount = _countof(strings);

2
2017-08-26 14:58



Je kunt nog steeds gebruiken

int numberofelements = sizeof(array)/sizeof(array[0]);

Dit is zo omdat sizeof(array)     retourneert de som van de grootten van aanwijzers die overeenkomen met elke tekenreeks. sizeof(array[0]) retourneert de grootte van de aanwijzer die overeenkomt met de eerste tekenreeks. Dus, sizeof(array)/sizeof(array[0]) geeft het aantal strings terug.


1
2017-12-08 10:28



We kunnen het aantal elementen van een array vinden door eenvoudigweg de size() functie.

Voorbeeldcode:

string exampleArray[] = { "Example", "Example2", "Example3" };
    int size_of_array = size(exampleArray);

cout << "Number of elements in array = " << size_of_array << endl;

Output:

>>> Number of elements in array = 3

Ik hoop dat het je helpt.


1
2018-06-06 18:52



Is dit wat je zoekt?

string array[] = {"Example", "Example2", "Example3"};
int num_chars = 0;
int num_strings = sizeof(array)/sizeof(array[0]);
for (int i = 0; i < num_strings; i++) {
    num_chars += array[i].size();
}

0
2018-01-13 22:32



Verplicht advies: gebruik std::vector<std::string>.

Een functie als deze kan helpen:

template<typename T, int sz>
int getSize(T (&) [sz])
{
    return sz;
}

Uw methode werkt ook omdat de grootte van de elementen niet varieert - a std::string heeft een constante grootte, ongeacht de werkelijke string die het bevat.


0
2018-01-13 22:33



Hier is een ander voorbeeld:

string array[] = {"Example", "Example2", "Example3"};
int numberofelements = 0; for(auto c: array) { numberofelements++; };
// now numberofelements will contain 3

0
2018-02-22 14:06