C++ 如何找到int[]的大小？

我有

如何获取

列表的大小

我知道对于char数组，我们可以使用
strlen（array）
查找大小，或者在数组末尾使用
'\0'
进行检查


正如一些答案所说，我尝试了
sizeof（array）/sizeof（array[0]）
，但它只在main中起作用？例如：

int list[] = {1, 2, 3};

为什么？
实现这一点的“标准”C方法是

int size(int arr1[]){
    return sizeof(arr1) / sizeof(arr1[0]);
}

int main() {
    int list[] = {1, 2, 3};

    int size1 = sizeof(list) / sizeof(list[0]); // ok
    int size2 = size(list_1); // no
    // size1 and size2 are not the same
}

试试这个：

sizeof(list) / sizeof(list[0])

因为这个问题是用C++来标记的，所以在C++中，总是建议使用<代码> STD:：向量< /代码>，而不是使用传统的C样式数组。

将
数组类型
传递给函数时，它会隐式转换为
指针类型
。
看看

为了正确打印任何函数中数组的大小，请通过引用将数组传递给该函数（但需要事先知道该数组的大小）

一般情况下，你会这样做吗

sizeof(list) / sizeof(list[0]);

模板
//模板参数推导
int size（T（&arr1）[N]）//通过引用传递数组
{
return sizeof（arr1）/sizeof（arr1[0]）；//正确返回'list'的大小
//或
返回N；//也正确返回大小[cool trick；-）]
}
对于动态分配的数组（或指针），您不能这样做。对于静态数组，可以使用
sizeof（array）
以字节为单位获取整个数组大小，并将其除以每个元素的大小：

template<typename T,int N> 
//template argument deduction
int size(T (&arr1)[N]) //Passing the array by reference 
{
   return sizeof(arr1)/sizeof(arr1[0]); //Correctly returns the size of 'list'
   // or
   return N; //Correctly returns the size too [cool trick ;-)]
}

要获取动态数组的大小，您必须手动跟踪它并将其传递，或者使用sentinel值终止它（如以null结尾的字符串中的“\0”）

 <强>更新：我意识到你的问题是C++的标签，而不是C。如果你想传递事物的话，你应该明确地考虑使用<代码> STD:：向量< /代码>代替C++中的数组：
#define COUNTOF(x) (sizeof(x)/sizeof(*x))

std:：vector v；
v、 推回（1）；
v、 推回（2）；
STD::CUT< P>除了卡尔的回答之外，“标准”C++方式不是使用C<代码> int 数组，而是像C++ STL<代码> STD:：向量列表< /> >，可以查询List.siz（）/< > > /p> ，基本上可以这样定义：

std::vector<int> v;
v.push_back(1);
v.push_back(2);
std::cout << v.size() << std::endl; // prints 2

模板
标准：大小（常数（&）[N]）
{
返回N；
}

注意，如果你想使用这个大小作为常量表达式，你就必须使用<代码>一个[sixA/sixe[/]代码>习惯用法或等待下一个C++版本的版本。
，因为你已经把它标记为C++，值得一提的是，有一种比C风格宏：
更好的方法。
template <typename T, std::size_t N>
std::size_t size(T const (&)[N])
{
    return N;
}

在C++11或更新版本中，可以添加
constexpr
以获取编译时常量：

int a[20];

char x[countof(a)];

模板
constexpr size_t countof（const t&array[N]）{return N；}

如果您真的希望在较旧的编译器上支持相同的功能，那么有一种方法，最初由AFAIK的Ivan Johnson发明：

template <class T, size_t N>
constexpr size_t countof(const T &array[N]) { return N; }

定义（x）的计数（\
0*sizeof（重新解释铸造（x））+\
0*sizeof（：：坏参数到计数：：检查类型（（x），&（x））+\
sizeof（x）/sizeof（（x）[0]））
类别错误参数到计数
{
公众：
类是_指针；
类是_数组{}；
模板
静态是指针检查类型（常数T*，常数T*常数*）；
静态是数组检查类型（常量无效*，常量无效*）；
};

它使用sizeof（x）/sizeof（x[0]）来计算大小，就像C宏一样，因此它提供了一个编译时常量。区别在于，如果传递的不是数组的名称，它首先使用一些模板魔术来导致编译错误。它通过重载check_type为指针返回一个不完整的类型，但为数组返回一个完整的类型。然后（真正棘手的部分）它实际上根本不调用该函数——它只接受函数将返回的类型的大小，对于返回完整类型的重载为零，但对于不完整类型则不允许（强制编译错误）

在我看来，这是一个非常酷的模板元编程的例子——尽管老实说，结果是毫无意义的。如果使用数组，实际上只需要将该大小作为编译时常量，在任何情况下通常都应该避免使用数组。使用
std:：vector
，可以在运行时提供大小（并在需要时调整向量大小）。
将任何数组传递给某个函数时。你只是传递它的起始地址，所以为了让它工作，你必须传递它的大小，也为了它正常工作。这与我们在命令行参数中用argv[]传递argc的原因相同。
您必须使用sizeof（）函数

代码段：
#包括
使用名称空间std；
int main（）
{
ios：：与stdio同步（false）；
int arr[]={5,3,6,7}；
int size=sizeof（arr）/sizeof（arr[0]）；
库特
基本上，sizeof（arr1）给出了所指向对象的大小，每个元素可能占用多个位，因此除以每个元素的位数（sizeof（arr1[0]）提供您正在查找的元素的实际数量，即我的示例中的4个。
此方法在您使用类时有效：在本示例中，您将收到一个数组，因此对我有效的唯一方法是以下方法：

int arr1[] = {8, 15, 3, 7};
int n = sizeof(arr1)/sizeof(arr1[0]);

模板
矩阵与算子=（T（&a）[n][m]）
{   
int arows=n；
int acols=m；
p=新双*[arows]；
for（寄存器int r=0；r

}

您可以制作一个模板函数，并通过引用传递数组来实现这一点

这是我的代码片段

template <typename T, size_t n, size_t m>   
Matrix& operator= (T (&a)[n][m])
{   

    int arows = n;
    int acols = m;

    p = new double*[arows];

    for (register int r = 0; r < arows; r++)
    {
        p[r] = new double[acols];


        for (register int c = 0; c < acols; c++)
        {
            p[r][c] = a[r][c]; //A[rows][columns]
        }

模板
无效打印数组（数据类型和数组类型）；
int main（）
{
charchararray[]=“我的名字是”；
int intArray[]={1,2,3,4,5,6}；
双双数组[]={1.1,2.2,3.3}；
打印阵列（charArray）；
打印阵列（intArray）；
打印阵列（双阵列）；
}
模板
vo
#include<bits/stdc++.h>
using namespace std;

int main()
{
      ios::sync_with_stdio(false);

      int arr[] ={5, 3, 6, 7};

      int size = sizeof(arr) / sizeof(arr[0]);
      cout<<size<<endl;

      return 0;
}

int arr1[] = {8, 15, 3, 7};
int n = sizeof(arr1)/sizeof(arr1[0]);

template <typename T, size_t n, size_t m>   
Matrix& operator= (T (&a)[n][m])
{   

    int arows = n;
    int acols = m;

    p = new double*[arows];

    for (register int r = 0; r < arows; r++)
    {
        p[r] = new double[acols];


        for (register int c = 0; c < acols; c++)
        {
            p[r][c] = a[r][c]; //A[rows][columns]
        }

template <typename TypeOfData>


void PrintArray(TypeOfData &arrayOfType);

int main()

{

    char charArray[] = "my name is";

    int intArray[] = { 1,2,3,4,5,6 };

    double doubleArray[] = { 1.1,2.2,3.3 };


    PrintArray(charArray);

    PrintArray(intArray);

    PrintArray(doubleArray);

}


template <typename TypeOfData>

void PrintArray(TypeOfData &arrayOfType)

{

    int elementsCount = sizeof(arrayOfType) / sizeof(arrayOfType[0]);


    for (int i = 0; i < elementsCount; i++)

    {

        cout << "Value in elements at position " << i + 1 << " is " << arrayOfType[i] << endl;

    }

}

int arraylength(int array[]) {
    return sizeof(array) / sizeof(int); // Size of the Array divided by the int size
}

int array_size(int array[]) {
    if(sizeof(array) == 0) {
        return 0;
    }
    return sizeof(array)/sizeof(array[0]);
 }