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?
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!
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();
as->length() will only give you the length of the first string kayak. Better use std::vector or std::array in c++11 –
Merriment as->length() and as->size() are giving you the same values, because they are giving you the count of letters in the first string kayak. en.cppreference.com/w/cpp/string/basic_string/size. To get the number of elements in the C-type array you have to use sizeof(as)/sizeof(as[0]), which should give you 8 as OP has mentioned –
Merriment 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
}
sizeofoperator? You simply cannot find the length of an array if the only thing you have is a pointer. –
Lorenlorena sizeof(whatever*) will always be the size of the pointer. Maybe you confuse it with anytype array[20] where sizeof(array)/sizeof(array[0]) is the number of elements in the array? There is no way to derive the number of array elements if you only have a pointer. –
Lorenlorena © 2022 - 2024 — McMap. All rights reserved.
std::vector, or astd::arrayif your compiler supports it. – Boulder