Finding the size of an array of strings in C++

Question

So I have an array of strings. Here's an example:

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

Is there any way I can find the number of elements in an array like the one above. I can't use this method:

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

This is because the size of the elements vary. Is there another way?

Answer 1

Given your array of strings, you can most certainly use sizeof(array)/sizeof(array[0]) to get its size and the following program works just fine:

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);
}

It is not clear what do you mean by saying that size of elements vary. Size of the elements of any array is always known at compiler-time, no exceptions.

There are, however, situations where the above will not work. Consider the following example:

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

The above code is doomed to fail. It might look a bit weird at first, but the reason for this is actually very simple — this is called array decaying. It means that every time you pass an array to a function, its type is automatically decayed to that of a pointer. So the above function is in fact an equivalent of this:

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

And if in the first example the sizeof operator returns the total size of an array, in the second example it returns the size of a pointer to that array, which is a totally different thing.

There are usually two ways people go about it. The first is to add a special “last” element of the array so that application can traverse the array until it sees the last element and calculate the array’s length. String literals are the perfect example of this — every string literal ends with ‘\0’ and you can always calculate its length. Here is an example:

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

The downside is obviously a need to traverse the array to determine its length. The second way it to always carry array length around, for example:

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++, you can use a template to deduct array’s length, for example:

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';
}

All of the above applies to simple arrays that are built-in into the language. C++, on the other hand, provides a rich set of higher-level containers that give you a lot of flexibility. So you might want to consider using one of the containers that are available to you as part of C++ Standard Library. For a list of standard containers, see — http://en.cppreference.com/w/cpp/container

Hope it helps. Good Luck!

Answer 2

You could use a template function to achieved that :

#include<cstdlib>

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

And like Luchian Grigore said, you should use STL containors. std::array if you want equivalent to static C array.

Answer 3

There is standart function in stdlib library:

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

Answer 4

You can still use

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

This is because sizeof(array) will return the sum of sizes of pointers corresponding to each string. sizeof(array[0]) will return the size of the pointer corresponding to the first string. Thus, sizeof(array)/sizeof(array[0]) returns the number of strings.

Answer 5

We can find the number of elements of an array by simply using the size() function.

Example Code:

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

Hope it helps you.

Answer 6

Is this what you're looking for?

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();
}

Answer 7

Mandatory advice: use std::vector<std::string>.

A function like this can help:

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

Your method also works because the size of the elements don't vary - a std::string has constant size, regardless of the actual string it holds.

Answer 8

Here is a different example:

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

Answer 9

string s[] = {"apple","banana","cherry","berry","kiwi"};
int size = *(&s+1)-s;  
// OR
int size = sizeof(s)/sizeof(s[0]);

for more info regarding the first one: https://aticleworld.com/how-to-find-sizeof-array-in-cc-without-using-sizeof/

Answer 10

no one actually counts duplicates so:

int count_duplicated(string cities[], size_t length) {
    string **cities_copy = new string *[length];
    for (size_t j = 0; j < length; j++)
        cities_copy[j] = &cities[j];

    string bom = "#";
    int counter = 0;
    for (size_t j = 0; j < length; j++) {
        string city = cities[j];
        bool is_duplicated = false;


        for (size_t k = j+1; k < length; k++) {
            if (city == *cities_copy[k]) {
                is_duplicated = true;
                cities_copy[k] = &bom;
            }
        }
        if (is_duplicated)
            counter++;
    }
    delete[] cities_copy;
    return counter;
}