Home / Questions / 74456
Accepted
user13558
Asked: 2020-05-31 09:28:27 +0800 CST 2020-05-31 09:28:27 +0800 CST

Получить длину массива с помощью функции в C++

  • 772

Если я попытаюсь отобразить длину массива в C++ с помощью функции sizeof, она правильно отобразит результат, который в данном случае равен 8.

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

Что мне не нравится, так это то, что слово нужно вводить array_enterosдважды, чтобы узнать длину, а для этого лучше было бы получить его через функцию.

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

В этом случае он возвращает 1, что является другим значением.

Не будет ли проблем в параметрах функции?

c++

5 Answers

  1. Best Answer

    Проблема.

    Проблема с вашей функцией obtener_longitud_arrayзаключается в том, что вы теряете информацию о размере при передаче параметра array_enteros(плюс вы можете вычислить размер только целочисленных массивов).

    Объяснение.

    C++ — это строго статически типизированный язык , это означает, что вы не можете изменять типы воobject время выполнения, и все имеет конкретный тип (без подстановочных знаков, таких как .net .

    Но иногда C++ создает ощущение динамической типизации, потому что в нем есть неявные преобразования типов. Одним из таких неявных преобразований является преобразование массива в указатель в соответствии со стандартом C++ (перевод и выделение мое):

    4.2 Преобразование массива в указатель

    Правостороннее или левостороннее значение типа «массив N T» или «массив неизвестного расширения T» может быть преобразовано в чисто правостороннее значение типа «указатель на T» . Результатом является указатель на первый элемент массива .

    Аранжировка N Tбудет:

    T arreglo[N];

    Где Tбудет любой тип и любое Nзначение.

    Неизвестное исправление расширения Tбудет:

    T arreglo[] = { ... }

    где Tбудет любой тип, и это тип массива, который вы используете в своем примере.

    При передаче массива array_enterosв функцию obtener_longitud_arrayмассив проходит вышеуказанное преобразование ( §4.2 ) и теряет свой первоначальный тип. Исходный тип массива содержит размер.

    Размер как часть шрифта.

    Массив N Tили массив с неизвестным расширением Tсодержит размер как часть своего типа:

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

    Вот почему размер можно определить с помощью перегрузок функций:

    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]

    Таким образом, ваша функция obtener_longitud_arrayможет быть шаблоном, который получает размер массива следующим образом:

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

    Или вы можете обобщить его для нецелочисленных типов , как это сделал Dolmens . Но вместо того, чтобы изобретать велосипед, я бы использовал стандартную утилиту std::extentзаголовка <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;
}
    • 15

  2. Проблема в том, что функция получает не массив, а указатель, который имеет размер 1, указатели работают как массивы, но это не одно и то же.

    Вы можете использовать макрос для решения этой проблемы

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

    а затем используйте GetSize, как если бы это была функция

    #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;
}
    • 11

  3. Поскольку вы работаете на C++, вы можете использовать способ ведения дел C++ : использовать template.

    1. С++ 11, constexpr:

    Компилируется без проблем с

    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. С++ 98, без constexpr :

    Единственное, что меняется, это именно удаление этого ключевого слова.

    Компилируется без проблем с

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

    Тестовый код:

    Действительно для C++98 и выше:

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

    Результат:

    Количество(v0): 0
    Количество(v1): 1
    Количество(v2): 2
    Количество(v3): 3

    Как видите, он различает исправления и не исправления . В первом случае возвращается количество элементов (независимо от того, указано ли это при объявлении переменной или опущено). Во втором возвращается 0.

    Почему 2 версии?

    Первое template не является строго необходимым. Это делается для того, чтобы избежать ошибок, если вы используете его для переменных , которые не являются массивами . Он использует особенность языка SFINAE : при попытке создать экземпляр шаблона и параметры не совпадают , он не выдает ошибку, а продолжает искать другие версии того ,template который соответствует.

    В нашем тестовом коде, если мы опустим первую версию шаблона

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

    Мой g++ выдает следующее:

    ошибка: нет соответствующей функции для вызова 'Countof(int&)'
    cout << "Countof(v0): " << Countof(v0) << "\n";
    ^
    примечание: кандидат: template constexpr size_t Countof(const T (&)[S])
    template< typename T, size_t S > inline constexpr size_t Countof( const T (&)[S]) { return S; }
    ^~~~~~~ примечание: ошибка вывода/подстановки аргумента шаблона:
    примечание: несовпадение типов 'const T [S]' и 'int' cout << "Countof(v0): " << Countof(v0) << "\п";

    Однако с обеими версиями компилятор пробует и то, и другое , и, в зависимости от случая, он добьется успеха с одним или другим. Именно эти попытки позволяют нам различать обычные переменные и массивы .

    • 6

  4. Другой способ сделать это, используя С++ 11 и 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 );
}

    Если T является многомерным массивом некоторого типа X, обеспечивает тип typedef члена, равный X, в противном случае тип — T.

    Что, в очень вольном переводе с моей стороны, звучит так:

    Если Tмногомерный массив типа X, возвращает значение, typedef typeравное типу X; в противном случае, сказал typedef, чтобы ввести T.

    • Если Tон имеет вид tipo[]...(с любым числом измерений , obtenemos el tipo baseT`.
    • Если T это не форма tipo[]..., мы все равно получаем тип T.

    Это можно использовать для получения размера любой переменной, независимо от того, является ли она массивом : если это так, мы можем получить размер ее базового типа; если это не так, мы все равно получаем размер базового типа. Поэтому в любом случае нам достаточно разделить размер переменной на typedef typeполученный из 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;
}

    Показывает следующее:

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

    • 3 
  5. #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;
}
    • 0