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

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.

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.

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.

There is standart function in stdlib library:

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

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.

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

Here is a different example:

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

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/

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

I test this code and it's work fine:

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

int asize = as->length();

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
}