Get the length of an array using a function in C++

Problem.

The problem with your function obtener_longitud_arrayis that you lose the size information when passing the parameter array_enteros(plus you can only calculate the size of integer arrays).

Explanation.

C++ is a strongly statically typed language , this means you can't change types atobject runtime and everything has a concrete type (no wildcard types like .net ) .

But sometimes C++ gives the feeling of being dynamically typed because there are implicit type transformations. One of these implicit transformations is the array-to-pointer transformation, according to the C++ standard (translation and emphasis mine):

4.2 Array-to-pointer conversion

A right-hand or left-hand-side value of type “array of N T” or “array of unknown extension of T” can be converted to a pure right-hand-side value of type “pointer to T” . The result is a pointer to the first element of the array .

Arrangement of N Twould be:

T arreglo[N];

Where Twould be any type and any Nvalue.

Unknown extension fix Twould be:

T arreglo[] = { ... }

where Twould be any type, and is the array type you are using in your example.

When passing the array array_enterosto the function obtener_longitud_array, the array goes through the above conversion ( §4.2 ) and loses its original type. The original type of the array contains the size.

Size as part of type.

An array of N Tor an array of unknown extension Tcontains the size as part of its type:

/* Tipo int       */ int i;
/* Tipo int[10]   */ int a[10];
/* Tipo double[3] */ double d[] { .0, .1, .2 };

This is why the size can be detected using function overloads:

void f(int[10]) { std::cout << "Arreglo 10.\n"; }
void f(int)     { std::cout << "Entero.\n"; }

f(a); // Muestra "Arreglo 10"
f(i); // Muestra "Entero"
f(d); // Error de compilacion, no existe funcion que acepte double[3]

So your function obtener_longitud_arraycould be a template that gets the size of the array like so:

template <std::size_t N>
std::size_t obtener_longitud_array(int[N]) { return N; }

Or you could generalize it for non-integer types like Dolmens has done . But instead of re-inventing the wheel I would use the standard library std::extentheader utility:<type_traits>

#include <iostream>
#include <type_traits>

int main()
{
    int array_enteros[]={'9','8','7','6','5','4','3','2'};
    std::cout << std::extent_v<decltype(array_enteros)> << '\n'; // 8
    return 0;
}

The problem is that the function does not receive an array, but a pointer, which has size 1, pointers work like arrays but they are not the same.

You can use a macro to solve this problem

#define GetSize(array_enteros) (sizeof(array_enteros)/sizeof(*(array_enteros)))

and then use GetSize as if it were a function

#include <iostream>
using namespace std;

#define GetSize(array_enteros) (sizeof(array_enteros)/sizeof(*(array_enteros)))

int main()
{
  int array_caracteres_enteros[]={'9','8','7','6','5','4','3','2'};
  int longitud=GetSize(array_caracteres_enteros);
  cout<<longitud<<endl;
  return 0;
}

Since you're in C++, you can use the C++ way of doing things : using template.

1. C++11, constexpr:

It compiles without problems with

g++ -Wall -Wextra -std=c++11 -pedantic

template< typename T > inline constexpr size_t Countof( const T (&) ) { return 0; }
template< typename T, size_t S > inline constexpr size_t Countof( const T (&)[S] ) { return S; }

2. C++98, without constexpr :

The only thing that changes is precisely the removal of that keyword.

It compiles without problems with

g++ -Wall -Wextra -std=c++98 -pedantic

template< typename T > inline size_t Countof( const T (&) ) { return 0; }
template< typename T, size_t S > inline size_t Countof( const T (&)[S] ) { return S; }

Test code:

Valid for C++98 and above:

#include <iostream>

using namespace std;

template< typename T > inline size_t Countof( const T (&) ) { return 0; }
template< typename T, size_t S > inline size_t Countof( const T (&)[S] ) { return S; }

int main( void ) {
  int v0;
  int v1[1];
  int v2[2];
  int v3[ ] = { 1, 2, 3 };

  cout << "Countof( v0 ): " << Countof( v0 ) << "\n";
  cout << "Countof( v1 ): " << Countof( v1 ) << "\n";
  cout << "Countof( v2 ): " << Countof( v2 ) << "\n";
  cout << "Countof( v3 ): " << Countof( v3 ) << "\n";

  return 0;
}

The output is:

Countof(v0): 0
Countof(v1): 1
Countof(v2): 2
Countof(v3): 3

As you can see, it distinguishes between fixes and non-fixes . In the first case, it returns the number of elements (whether specified when declaring the variable or omitted). In the second, it returns 0.

Why 2 versions?

The first is template not strictly necessary. It is to avoid errors if you use it on variables that are not arrays . It makes use of the SFINAE feature of the language: when trying to instantiate a template and the parameters don't match , it does n't raise an error, but keeps looking for other versions of the templateone that do match.

In our test code, if we omit the first version of the template

// template< typename T > inline size_t Countof( const T (&) ) { return 0; }

My g++ spits out the following:

error: no matching function for call to 'Countof(int&)'
cout << "Countof( v0 ): " << Countof( v0 ) << "\n";
^
note: candidate: template constexpr size_t Countof(const T (&)[S])
template< typename T, size_t S > inline constexpr size_t Countof( const T (&)[S] ) { return S; }
^~~~~~~ note: template argument deduction/substitution failed:
note: mismatched types 'const T [S]' and 'int' cout << "Countof( v0 ): " << Countof( v0 ) << "\n";

However, with both versions, the compiler tries both , and, depending on the case, it will succeed with one or the other. These attempts are what allow us to discriminate between normal variables and arrays .

Another way to do it, using C++11 and the template std::remove_all_extents< T >:

#include <cstddef>
#include <type_traits>

template< typename T > constexpr ::std::size_t countof( const T & ) noexcept {
  return sizeof( T ) / sizeof( typename ::std::remove_all_extents< T >::type );
}

If T is a multidimensional array of some type X, provides the member typedef type equal to X, otherwise type is T.

Which, in a very free translation on my part, comes to say:

If Tis a multidimensional array of type X, returns an typedef typeequal to type X; otherwise, said typedefis to type T.

• If Tit is of the form tipo[]...(with any number of dimensions , obtenemos el tipo baseT`.
• If T it is not of the form tipo[]..., we still get the type T.

This can be used to get the size of any variable, whether or not it is an array : if it is, we can get the size of its base type; if it is not, we still get the size of the base type. Therefore, in any case, it is enough for us to divide the size of the variable by that typedef typeobtained from the template:

#include <iostream>
#include <cstddef>
#include <type_traits>

using namespace std;

template< typename T > constexpr size_t countof( const T & ) noexcept {
  return sizeof( T ) / sizeof( typename remove_all_extents< T >::type );
}

int main( ) {
  int a1;
  int a2[2];
  int a3[3][3];
  char str[] = "Hola mundo !";

  cout << "countof( a1 ) " << countof( a1 ) << "\n";
  cout << "countof( a2 ) " << countof( a2 ) << "\n";
  cout << "countof( a2 ) " << countof( a3 ) << "\n";
  cout << "countof( str ) " << countof( str ) << endl;

  return 0;
}

Shows the following:

countof( a1 ) 1
countof( a2 ) 2
countof( a2 ) 9
countof( str ) 13

#include <iostream>
using namespace std;

int longitud_array (int x, int y)
{
    int la = x / y;
    return la;
}
int main ()
{
    int array_enteros[] = {9, 8, 7, 6, 5, 4, 3, 2};
    int longitud = longitud_array(sizeof(array_enteros), sizeof(array_enteros[0]));
    cout << "La dimensión del array es de " << longitud << " y sus posiciones van del 0 al " << longitud-1 << endl;
    return 0;
}