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

NOTE: sizeof(array) will no longer return the full size of the array in Windows, but only the size of the pointer. The standard libraries in Windows have quietly changed this to allow for use of their additional libraries such as std:array and std::iterator. You will need to use the functions from these libraries or create your own methods to count the elements. This is a sample for those that cannot use std::array or std::iterator due to library conflicts or other reasons.

size_t SizeOfArray(std::string* inComing)
{
  size_t outGoing = 0;
  bool end = false;
  // Validate Array
  if (inComing != NULL)
  {
    // Appended arrays can be valid or not. Sometimes earlier cleanup
    // will link to an empty array location, so check for empty and invalid. 
    while ((!end) && (inComing[outGoing].size() != 0))
    {
      __try
      {
        // if an appended memory location has value, but is not an array
        // you look for the NULL character. For wstrings change '\0' to L'\0'.
        // If the memory location is not valid, it will throw the exception.
        if (inComing[outGoing].c_str()[inComing[outGoing].length()] != '\0')
        {
          // End of array -  if nice empty value
          end = true;
        }
        else
        {
          outGoing++; // Count each valid string in the array
        }
      }
      // This is the blank exception catch to an extra element that is not
      // valid.
      __except (EXCEPTION_EXECUTE_HANDLER)
      {
      // End of array -  if unknown value
      end = true;
      }
    }
  }
  return outGoing; // Return the count
}

Answer 2

I test this code and it's work fine:

string as[] = {"kayak","deified","rotator","repaper","deed","peep","wow","noon"};

int asize = as->length();

Answer 3

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

Answer 4

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 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

Here is a different example:

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

Answer 7

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 8

There is standart function in stdlib library:

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

Answer 9

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 10

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 11

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 12

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