定义有什么问题？

Question

I'm trying to compile "libsamplerate.dll" with Visual Studio VC++ 2015 on Windows10, referring to: http://www.mega-nerd.com/SRC/win32.html .

Then, I got the following errors:

termination_test.c
.\tests\termination_test.c(82): error C2057: expected constant expression
.\tests\termination_test.c(82): error C2466: cannot allocate an array of constant size 0
.\tests\termination_test.c(82): error C2133: 'in': unknown size
.\tests\termination_test.c(83): error C2057: expected constant expression
.\tests\termination_test.c(83): error C2466: cannot allocate an array of constant size 0
.\tests\termination_test.c(83): error C2133: 'out': unknown size
NMAKE : fatal error U1077: '"C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\cl.exe"' : return code '0x2'

"termination_test.c" is originally from: http://www.mega-nerd.com/SRC/download.html and here is the function which causes the errors:

static void
simple_test (int converter)
{
    int ilen = 199030, olen = 1000, error ;

    {
        float in [ilen] ;
        float out [olen] ;
        double ratio = (1.0 * olen) / ilen ;
        SRC_DATA src_data =
        {   in, out,
            ilen, olen,
            0, 0, 0,
            ratio
        } ;

        error = src_simple (&src_data, converter, 1) ;
        if (error)
        {   printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
            exit (1) ;
            } ;
    } ;

    return ;
} /* simple_test */

I simply modified these two lines to:

        float in [199030] ;
        float out [1000] ;

... then, worked perfectly.

However, what's wrong with the definition?

int ilen = 199030, olen = 1000, error ;

I put 'const' in front of int, then I got another error "C2166: l-value specifies const object". How can I make it error-free?

(PS, This is an open-source code, so there shouldn't be any errors. This isn't a question, but I just wonder why.)

Answer 1

Visual Studio doesn't support variable length arrays.

The variables ilen and olen that defined the size of the array are not constant expressions (from here on described as: constants), so the following are variable length arrays:

float in [ilen] ;
float out [olen] ;

Values 199030 and 1000 are constants, so the following are just regular arrays:

float in [199030] ;
float out [1000] ;

Defining an object with a const qualifier will not make an object a constant.

You can use #define to define your values as macros, but this is identical to writing the constants manually, as the defined macros are replaced before compiling the code with the values they denote.

#define ILEN 1000
int array[ILEN];

is converted to:

int array[1000];

before before compiling begins.

Of course you should use #define as it is much more convenient and less error-prone.

Answer 2

Continuing from the comment, the subtle point you were missing is that in C, array declaration requires a constant expression for the array size (eg array[CONST] ). fn1. When you declare:

int ilen = 199030, olen = 1000, error ;

Neither ilen or olen are constant expressions . (the easy way to think about it is you could easily do ilen = ilen + 2; -- so ilen isn't a constant expression .)

Constant expressions are generally created by macro with #define or enum (which create global constants). (and you generally CAPITALIZE constants -- just to distinguish then from other variables). So you could do:

#define ILEN 199030
#defile OLEN 1000

or

enum { OLEN = 1000, ILEN = 199030 };

and then declare your float arrays:

float in [ILEN],
     out [OLEN];

fn 1. Modern C compilers allow allow the use of the variable length array which can be declared in the way you have attempted, but as others have pointed out, your compiler does not support VLAs.

Answer 3

The size of an array, at least in C89, must be a costant expression. A costant expression is an expression whose value doesn't change. Here's few examples of constant expressions:

#define SIZE (200)
...
int v[200];/* Ok*/
int w[200 + 1]; /*Ok because 200 + 1 does always 201*/
int y[SIZE]; /* Better*/
...

This implies that you cannot use a variabile to specify the array size, even if you declare it using "const" keyword because you fan change value of a const value by taking advantage of pointers.

int n = 10;
const int size = 10;
int v[n]; /* Wrong in C89 and non C99 fully compliant compilers!*/
int x[size]; /* Again, not valid because costant value != costant expression*/

To verify that const value can be changed,try this:

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    const int a = 0;
    int *p = &a;
    printf("Now a is %d\n",a);
    *p = 1;
    printf("Now a is %d\n",a);
    return EXIT_SUCCESS;


}

You'll see that a's value changes after the first call to printf. This behaviour is anyway compiler-dependant,in fact GCC allows you to change a const value but clang doesn't. That's why you can't use variables for the size of an array. C99 standards introduced VLAs (Variable Lenghts Arrays) and many other orrible features. With -std=c99 flag (or equivalent for non-GCC compatible compilers) you can use variables for specifying the size of an array, but this is a bad thing to do because it hides a call to malloc. C99 extensions were substantially introduced on favor of GCC and Numerical C and nowdays many compilers reject some features of C99 standards. Visual Studio compiler does not -rightly- support VLA,so you have two options: - use malloc - avoid dynamic memory (preferable)

In serious contexts malloc is not an option since it is strictly forbidden by strict standards such as MISRA/C and NASA subset. But even in "not so critical" environment avoiding the use of malloc is a good practice because it makes easier for you to write predictable and bug free code since you don't have to worry about memory leaks, forgotten free() etc. The solution consists in allocating a big pool of memory at the very beginning of the program and using it when needed.

To sum up the best way to declare an array is:

#define SIZE (...)
...
int v[SIZE];
...