Си error variable sized object may not be initialized

C & C++, Linux & Networking World

Search This Blog

error: variable-sized object may not be initialized

• Get link
• Facebook
• Twitter
• Pinterest
• Email
• Other Apps

Have you ever come across this error??

«Understand the error thoroughly, so that it is not required to google in the future» — That’s what I say to myself.

This error says,
1. Initialization has a problem.
2. Variable-length array has a problem.

The reason for the above error is we initialized the variable-length array which is not recommended.

char ARR_SIZE = 15;
char arr[ARR_SIZE];
char arr[ARR_SIZE] = <>; //error
char arr[ARR_SIZE] = <0>; //error

An array size can’t be assigned by another initializer (n = 15), but if the size is assigned by an initializer, it becomes a variable-length array. These variable-length arrays are prohibited from being initialized.

The type of entity to be initialized shall be an array of unknown size or an object type that is not a variable-length array type, so the problem is with initialization.

This issue can be solved by two-ways.

1. The type of entity to be initialized shall be an object type that is not a variable-length array type.

Another way of assigning array size is,

2. The type of entity to be initialized shall be an array of unknown size.

Hence, the problem is with initialization with variable-length and not a declaration.

This problem is applicable to integer arrays as well.

Integer array initialization also can be solved by the above two methods.

Источник

[SYCL] error: variable-sized object may not be initialized #887

Is it supposed to be ok? If yes, how can i use a dynamic multidimensional array with USM?

The text was updated successfully, but these errors were encountered:

Hi,
it seems that it’s impossible to capture variable length array by value.
The new_image variable cannot be captured in a standard C++ lambda like:

Compiler gives the same error message on such code.

I believe you need to initialize new_image using malloc_shared to use it in the kernel(preudo-code):

However the crash after diagnostics is a bug.

@romanovvlad thanks. I’ve changed the code following your tip but i have a similar issue.

Hi,
old_image should be allocated in the same way. Attaching diff.
usm_allocation.diff.txt

@romanovvlad i’ve tested in small arrays and it works, but with huge arrays (20000*40000 bytes) it gives me a segmentation fault. Looking with gdb this is the backtrace:

Hm sounds like an issue in compute runtime, suggest creating issue there https://github.com/intel/compute-runtime/issues

I have the feeling that you should use just a 2-D array instead of an array of array, since all the dimensions seem to be constexpr if you do not need this complex data structure.
Even on a CPU this double indirection is inefficient anyway.
But in this example, you could just use 2-D cl::sycl::buffer + accessors instead of USM and explicit memory management.
It gives you this 2-D array-like interface through the accessor for free!

Hi @keryell , i’ve already tried the implementation with the cl::sycl::buffer (you can find here https://github.com/cagnulein/sycl-benchmarks/blob/master/rotate/rotate.cpp) and it works; it has only big issue: is really slow copying 800MB of data from the CPU to GPU and back.

With the USM, if i didn’t misundarstood them, i will run my alghoritm without copying around my buffer. And when it works, it works very quickly! I talk about 8x times faster than cl::sycl:buffer mode.

What do you think?

I see. It depends probably on the the GPU architecture. If you have some efficient shared hardware access between CPU and GPU that makes sense. Otherwise, a 2-D buffer with the right access mode in the accessors (such as write_only. ) might be more efficient, with a minimal number of huge copy instead a gazillions of inefficient individual accesses,

But my 2-D array suggestion was at the first place that it seems super inefficient to have arrays of arrays like

instead of just a plain old C 2-D array:

See https://godbolt.org/z/XkAWqe to get a simpler idea about why it should work (I have not tried myself with oneAPI. )

I hope in the future USM will be extended to allow «just»:

that would provide also some nice alignment properties as a side effect.

A limitation of the current compiler that might not handle references?
Can you try removing the reference by using instead for example

and replacing the old_image by (*old_image) where it is used?

@keryell i’ve tried but this is the result:

Is it supposed to be ok? If yes, how can i use a dynamic multidimensional array with USM?

Источник

C compile error Variable-sized object may not be initialized with char * pt

Yes I did read these two posts.

My case is a bit different because I’m using char * ptr[buflen] . This is what I have tried:

3 Contributors 2 Replies 8K Views 1 Day Discussion Span Latest Post 7 Years Ago Latest Post by deceptikon

This has to do with what is known at compile time in C. Unless you are using C99 or C++, char *ptr[bufflen] won’t compile. In C89/90, the array size must be a compile time constant, meaning that it is either a number or a macro like so:

This has to do with what is known at compile time in C. Unless you are using C99 or C++, char *ptr[bufflen] won’t compile. In C89/90, the array size must be a compile time constant, meaning that it is either a number or a macro like so:

If you are writing C89/90, your code is compiling due to a compiler extension. I’m not sure of the rationale behind not allowing VLA (variable length array) initializers, but, since it is only allowed as a compiler extension in C89, all you need to know is the compiler doesn’t like it. As for char *strings_line_tokens[503] = <0>; , this is standard C code (as far as I know). As a side note, if you write this at global scope, it gets 0 initialized for you, so you dont need the = <0>part.

The work aroung for this is malloc/calloc. Before I go further, I want to make sure you know what you are allocating. char *ptr[20]; is an array of 20 pointers to char. Thus, its size is sizeof(char*)*20 not buflen*buflen*sizeof(char) . Since you seem to want to initialize your array with zeros, you should consider using calloc instead of malloc, as it will do it for you:

Calloc takes the number of things you want to allocate as its first parameter and the size of each individual thing as its second one.
For learning purposes, here is what it would look like if you were to initialize it manually:

If you are intentionally using VLAs (either through an extension or with C99/C++), you could use memset on it the same way:

The only difference is that you are using an array on the stack, so you don’t have to free it. You do, however, have to free the pointers you get from malloc and calloc, as they are on the heap. Keep in mind, though, that if you store any pointers in your array that point to memory on the heap, you will need to keep track of those pointers ouside of the function or free them before the function returns. Otherwise, you will leak memory.

The last thing I want to mention is that in char *ptrs[20]; «ptrs» is an array while in char* ptrs = (char*)calloc(20, sizeof(char*)); «ptrs» is a pointer that points TO an array on the heap. Thus, sizeof(ptrs) will evaluate to 20*sizeof(char*) in the array version and sizeof(char*) in the calloc version.

I hope this helped!

I’m not sure of the rationale behind not allowing VLA (variable length array) initializers

It’s a combination of not complicating the compiler and not hiding an extremely volatile runtime task behind benign syntax. Even in C99+, VLAs are risky and not something I’d recommend using. Robust code shouldn’t use them, as failure to allocate cannot be recovered from. A solid solution would still use the gamut of VLA, static array, and dynamic array, so cutting out the VLA part would actually simplify code.

you should consider using calloc instead of malloc

I’m torn between saying «no» and «hell no». The problem here is that an array of pointers is being allocated, and calloc encourages a false sense of security that those pointers are initialized to NULL . NULL need not be synonymous with all bits zero, which is what calloc does.

Otherwise, kudos for a good post. You get my upvote. 🙂

Источник

Ошибка компиляции C: «Объект переменного размера не может быть инициализирован»

Почему я получаю сообщение об ошибке «Объект переменного размера не может быть инициализирован» с помощью следующего кода?

задан 21 июн ’10, 04:06

Как указано в отличном ответе Дэвида Родригеса: если длина является переменной, вам нужен memset, но если длина является константой времени компиляции, тогда оператор компилируется нормально. — Casey

ffwd к 2020 году — enum ; int boardAux[length][length] = <0>; — Chef Gladiator

сделать это const int решил эту проблему для меня. — Mote Zart

10 ответы

Я предполагаю, что вы используете компилятор C99 (с поддержкой массивов динамического размера). Проблема в вашем коде заключается в том, что в то время, когда компиляторы видят ваше объявление переменной, он не может знать, сколько элементов находится в массиве (я также предполагаю здесь из-за ошибки компилятора, что length не является постоянной времени компиляции).

Вы должны вручную инициализировать этот массив:

Я могу использовать для этой цели и malloc, насчет второго вопроса, я написал его после ответа Павла — Привет мир

@helloWorld: с выделенными стеком массивами, printf( «%d», boardAux[1][2] ) компилируется нормально. Компилятор знает размеры и знает, в какой позиции в памяти находится (1,2) -й элемент. Если вы используете динамическое размещение, массив является одномерным, и вы должны выполнить математику самостоятельно: printf(«%d», boardAux[ 1*length + 2 ]) — Давид Родригес — дрибеас

@AndreyT: Спасибо, что указали на ошибку в memset вызывать. Я только что поправил. — Давид Родригес — дрибеас

Почему я получаю эту ошибку в компиляторе C99, когда устанавливаю length быть static ? В C ++ 14 все работает нормально. — Силидрон

Я хочу знать причину почему malloc не требуется. — лабиринт

Вы получаете эту ошибку, потому что в языке C вам не разрешено использовать инициализаторы с массивами переменной длины. Сообщение об ошибке, которое вы получаете, говорит само за себя.

3 Тип инициализируемого объекта должен быть массивом неизвестного размера или типом объекта, который не является типом массива переменной длины.

где ты это нашел, можешь дать ссылку? — Привет мир

@helloWorld: это из языкового стандарта (C99). Вы можете получить «рабочую» копию с обновлениями TC3 здесь open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf — Муравей

Есть темы, по которым некоторые всегда не поверят вам, если вы предоставите только неформальное объяснение. Массивы переменной длины — одна из таких тем. +1 за цитирование стандарта. — Паскаль Куок

@AnT Я запускаю код на C ++, он отлично компилируется, поэтому инициализация массива переменного размера допустима в C ++? — Абхишек Мане

@Abhishek Mane: Нет. В C ++ вообще нет массивов переменного размера. — Муравей

Это дает ошибку:

Это также дает ошибку:

Но это нормально работает:

Вам нужно определить стоимость следующим образом:

После объявления массива

Самый простой способ присвоить начальным значениям ноль — использовать цикл for, даже если он может быть длинноватым

ответ дан 27 мар ’16, в 13:03

memset проще и быстрее. — ALX

На этот вопрос уже дан ответ, но я хотел бы указать на другое решение, которое работает быстро и работает, если длина не должна изменяться во время выполнения. Используйте макрос #define перед main (), чтобы определить длину, и в main () ваша инициализация будет работать:

Макросы запускаются до фактической компиляции, и длина будет постоянной времени компиляции (как указано в ответе Дэвида Родригеса). Фактически перед компиляцией длина будет заменена на 10.

ответ дан 12 апр.

есть ли реальная разница между <0>и <<0>> ? — ITJ

Массив не инициализируется указанной памятью, и выдает ошибку. variable sized array may not be initialised Я предпочитаю обычный способ инициализации,

Просто объявите длину недостатком, если это не так, вы должны динамически распределять память.

ответ дан 02 мар ’16, в 20:03

Я думаю, вам нужно узнать, что означает const! — Хольгер

@Holger: Ты уверен? Если переменная, содержащая длину (не сам массив, а длина массива), является константой, то компилятор знает длину, используемую для инициализации массива. Например, «int length = 5; int array [length];» выдает ошибку, но «Const int length = 5; int array [length]; «компилируется отлично. — Кейси

@Casey: но const int lenght=5; int array[length][length] = <<0>>; не буду. — местрелев

Источник

error: variable-sized object may not be initialized

Have you ever come across this error?? 

«Understand the error thoroughly, so that it is not required to google in the future» — That’s what I say to myself.

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

int main()
{   
    int n = 15;
    char arr[n] = "Stunning Palace";
    printf("Arr [%s] and sizeof(arr) [%d] strlen(arr) [%d]n", arr, 
            sizeof(arr), strlen(arr));
    
    return 0;
}
Output:








In function 'main':
Line 7: error: variable-sized object may not be initialized







This error says,

1. Initialization has a problem.

2. Variable-length array has a problem.
The reason for the above error is we initialized the variable-length array which is not recommended.
char ARR_SIZE  = 15;

char arr[ARR_SIZE];

char arr[ARR_SIZE] = {};  //error

char arr[ARR_SIZE] = {0}; //error
An array size can’t be assigned by another initializer (n = 15), but if the size is assigned by an initializer, it becomes a variable-length array. These variable-length arrays are prohibited from being initialized.
#include <stdio.h>
#include <string.h>

int main()
{   
    char ARR_SIZE  = 15;
    char arr[ARR_SIZE] = {};
    
    printf("Arr [%s] and sizeof(arr) [%d] strlen(arr) [%d]n", arr, 
            sizeof(arr), strlen(arr));
    
    return 0;
}
Output:








In function 'main':
Line 7: error: variable-sized object may not be initialized






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

int main()
{   
    char ARR_SIZE  = 15;
    char arr[ARR_SIZE] = {0};
    
    printf("Arr [%s] and sizeof(arr) [%d] strlen(arr) [%d]n", arr, 
            sizeof(arr), strlen(arr));
    
    return 0;
}
Output:








In function 'main':
Line 7: error: variable-sized object may not be initialized
Line 7: warning: excess elements in array initializer
Line 7: warning: (near initialization for 'arr')






The type of entity to be initialized shall be an array of unknown size or an object type that is not a variable-length array type, so the problem is with initialization. 
This issue can be solved by two-ways.
1. The type of entity to be initialized shall be an object type that is not a variable-length array type.
#include <stdio.h>

int main()
{   
    int n = 15;
    char arr[n];

    sprintf(arr, "Stunning Palace");
    printf("Arr [%s] and sizeof(arr) [%d] strlen(arr) [%d]n", arr, 
            sizeof(arr), strlen(arr));
    
    return 0;
}
Output:








Arr [Stunning Palace] and sizeof(arr) [15] strlen(arr) [15]






Another way of assigning array size is,
#include <stdio.h>
#define ARR_SIZE 15

int main()
{   
    char arr[ARR_SIZE] = "Stunning Palace";
    printf("Arr [%s] and sizeof(arr) [%d] strlen(arr) [%d]n", arr, 
            sizeof(arr), strlen(arr));
    
    return 0;
}
Output:








Arr [Stunning Palace] and sizeof(arr) [15] strlen(arr) [15]







2. The type of entity to be initialized shall be an array of unknown size.
#include <stdio.h>
#include <string.h>

int main()
{
   char arr[] = "Stunning Palace";

    printf("Arr %s and sizeof(arr) %d strlen(arr) %dn", arr, sizeof(arr), strlen(arr));
    
    return 0;
}
Output:








Arr Stunning Palace and sizeof(arr) 16 strlen(arr) 15







Hence, the problem is with initialization with variable-length and not a declaration.
This problem is applicable to integer arrays as well.
#include <stdio.h>

int main()
{
    int n = 6;
    int arr[n] = {1, 2, 3, 4, 5, 6};

    printf("Array before memset() arr %d and sizeof(arr) %d n", arr[5], sizeof(arr));
    
    return 0;
}
Output:








In function 'main':
Line 6: error: variable-sized object may not be initialized
Line 6: warning: excess elements in array initializer
Line 6: warning: (near initialization for 'arr')
Line 6: warning: excess elements in array initializer
Line 6: warning: (near initialization for 'arr')
Line 6: warning: excess elements in array initializer
Line 6: warning: (near initialization for 'arr')
Line 6: warning: excess elements in array initializer
Line 6: warning: (near initialization for 'arr')
Line 6: warning: excess elements in array initializer
Line 6: warning: (near initialization for 'arr')
Line 6: warning: excess elements in array initializer
Line 6: warning: (near initialization for 'arr')







Integer array initialization also can be solved by the above two methods.