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 数组到指针的转换

    “array of N T”或“array of unknown extension ofT ”类型的右侧或左侧值可以转换为“pointer to T”类型的纯右侧值。结果是指向数组第一个元素的指针。

    安排N T将是：

    T arreglo[N];

    哪里T是任何类型和任何N值。

    未知的扩展修复T将是：

    T arreglo[] = { ... }

    whereT可以是任何类型，并且是您在示例中使用的数组类型。

    将数组传递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. C++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. C++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

    如您所见，它区分了fix和non- fixes。在第一种情况下，它返回元素的数量（无论是在声明变量时指定还是省略）。在第二个中，它返回.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 ) << "\n";

    但是，对于这两个版本，编译器都会尝试两者，并且根据情况，它会在其中一个或另一个上成功。这些尝试使我们能够区分普通变量和数组。

    • 6

  4. 另一种方法是使用 C++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 的多维数组，则提供等于 X 的成员 typedef type，否则 type 为 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;
}

    显示以下内容：

    计数（a1）1
    计数（a2）2
    计数（a2）9
    计数（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