标签: variable-length-array

当出现一些问题时,我正在研究一个带有非类型参数的模板函数(以避免数组的动态分配).我的第一个问题是编译时变量赋值.这是因为以下尝试调用模板函数:

template<int n>
int *getDegrees(int A[][n]) {
  //return degrees
}

int main(int argc, char **argv) {
  int n = 10;
  int A[n][n];
  int *degs = getDegrees<n>(A);
}

在这里,我们有两个错误:第一,编译器无法解析对以下内容的调用getDegrees(A):

main.cc:27: error: no matching function for call to ‘getDegrees(int [(((long unsigned int)(((long int)n) + -0x00000000000000001)) + 1)][(((long unsigned int)(((long int)n) + -0x00000000000000001)) + 1)])’

其次,我们无法n在模板调用中使用,因为它不是常量表达式.简单地n保持不变可以解决问题

const int n = 10;

但是,如果我这样做的话

int m = 10;
const int n = m; 

我们得到了同样的错误.虽然编译器可能允许第二个赋值,但它是否被认为是不好的形式？另外,为什么n在解决函数调用时不断有所作为呢？

我的另一个问题是关于vlas:在堆栈或堆上为它们分配的内存(并且这是依赖于编译器的)？即使在C++中允许它们似乎也存在争议,是否应该避免使用向量(或类似的容器)？

欣赏任何见解!

据我所知,(我是c的初学者)你可以定义数组的大小,前提是用户知道用户将提供多少输入.但是,如何根据输入数量定义数组的大小？

例如,如果我必须提供10个数字作为输入,那么我如何以这样的方式声明一个数组,根据我的输入计数将其大小指定为10？(我不知道是否有可能,但我想知道)

我试图理解sizeof运算符的工作,我遇到了 这个 问题.以下是该问题的代码

#include <stdio.h>

int main() {
    int i = 0;
    int a[i];
    printf("%zu\n",sizeof(a[i++]));
    printf("%d\n",i); // Here, print 0 instead of 1
    return 0;
}

数组a这里是可变长度但是当它用作sizeof运算符的操作数时,变量i不会递增.

一些评论和答案说这a[i++]不是VLA类型,并建议op应该使用2D VLA来查看副作用(sizeof评估其oprand).

我不清楚为什么a[i++]不符合VLA表达的条件.我认为这与我们可以在传递给一个函数时保留第一个未指定数组的事实有关.

所以问题一般是什么被认为是VLA表达？

testList= []
testList[12]= 31
testList[23]= 1337

Error: IndexError: list assignment index out of range

基本上，我有唯一的Integer，并且我想将列表用于哈希函数h（x）= x（因为它们是唯一的）

我可以这样初始化长度：

testList= [0 for i in range(50)]

但是然后我必须确定大小和我的唯一数字，随着时间的推移，这些数字和唯一数字会增加。可以将大小设置为例如1-2Mio，还是可以动态地执行此操作？Java中的ArrayList <>是动态用于附加和删除的，Python中的List也是如此。

谢谢！

什么时候用 calloc 实例化可变长度数组比用 C 中的“普通”数组声明更好？

考虑“数组声明”方法：

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{

    int n = atoi(argv[1]);
    int x[n];

    for(int i = 1; i < n; i++){
        x[i] = i;
        printf("%i", x[i]);
        printf("\n");
    }
    return 0;
}

与 calloc 方法相比：

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{

    int n = atoi(argv[1]);
    int * x = (int*) calloc(n, sizeof(int));

    for(int i = 1; i < n; i++){
        x[i] = i;
        printf("%i", x[i]);
        printf("\n");
    }
    return …

我在 Visual Studio 中使用 C 编写了一个代码，供用户输入数组的大小。

该代码无法在 Visual Studio 中运行并给出错误。

但在像 replit 这样的网站上它是有效的。

我不明白如何才能使其在 Visual Studio 中工作。

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <math.h>

int main()
{
    int m;
    do
    {
        printf("please enter array size--> ");
        scanf_s("%d", &m);
    } while (m <= 1);

    int arry[m];

    for (int i = 0 + 1; i < m + 1; i++)
    {
        printf("%d,", arry[i] = i);
    }

    return 0;
}

我想在C++ 20中将浮点向量转换为浮点数组。我在网上搜索并找到了这个解决方案：

#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    std::vector<int> input({ 1, 2, 3, 4, 5 });
 
    int arr[input.size()];
    std::copy(input.begin(), input.end(), arr);
 
    for (int i: arr) {
        std::cout << i << ' ';
    }
 
    return 0;
}

但是当我尝试实现它时，编译器给出一个错误，指出数组声明中括号内的内容必须是常量表达式。

从什么时候开始出现这种情况了？我发誓我以前在 C++ 中以类似的方式声明过数组并且它有效。如果您在网上查看，您会发现每个人也这样做，我发布的示例似乎是我的问题的标准解决方案。那么为什么它会给我一个错误呢？

如此简单的代码如:

int n;
cin >> n;
int s[n], p[2*(n-1)][3];

我必须翻译成:

int  n;
cin >> n;
vector<int> s(n, 0);
vector<vector<int>> p(2 * (n - 1), vector<int>(3));

我希望看到类似的东西:

int  n;
cin >> n;
mat s(n), p(2*(n-1), 3);

我绝对不想使用new\make_unique和std::array+ std::vector混合这样简单的东西.两条线是一个丑陋的混乱恕我直言,所以我希望有一种方法来保持C像sintax.

那么什么是变通方法？任何定义/标准头/ copy -matable基于STL的C++类型？

问题如下：

使用以写入 0 结尾的 for 循环，计算偶数之和、奇数之和，

我不知道为什么我的代码不起作用：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int i = 0, num[i], sum, even, odd;
        
    for (;;) {
        printf("Write a number: ");
        scanf("%d", &num[i]);
        if (num[i] == 0) {
            break;
        }
        if (num[i] % 2 == 0) {
            even += num[i];
        } else
            odd += num[i];
            i++;
        }
       
        printf("Sum of even is: %d\n", even);
        printf("Sum of odd is: %d", odd);
        return 0;
    }

我有这个代码

int e;
scanf("%d",&e);
int ar[e];

这是动态分配吗？它看起来真的像我可以在运行时分配内存.

我用它来获取用户输入的元素数量,然后由用户再次填充.

以下代码段使用标准正确编译gcc。这里可能存在哪些陷阱？--特别是对于内核级开发。

int n;

f(){n=2;}
g(){int b[n];}

main(){
        int a[n];
        f();
        g();
}