c++ 程序如何返回我的数组或写入全局变量

Question

I am new with C++ and I have to write code, but somehow it is not working and I do not know what I can change. I would like to give back the array Grad, but it says segmentation fault (core dumped). Could somebody help me with what I have to change? Or is it possible to have a global variable and write from the function directly to the global variable? Thanks for your help.

Code:

double* Gradient(const double x[], int n1) {
    double Grad [n1*4] = {0};
    // We calculate the overlap. If the overlap is zero, the gradient
    // is also zero. This should be probably improved in the future.
    //int n = sizeof(x)/32;
    for (int i = 0; i < n1*4; i++)
    {
        for (int j = 0; j < n1*4; i++)
        {
            if (i != j)
            {
                //cout << x[i]<< endl;
                double xmin = max(x[i*4], x[j*4]);
                double xmax = min(x[i*4+1], x[j*4+1]);
                //if (xmin > xmax) return Grad;
                double ymin = max(x[i*4+2], x[j*4+2]);
                double ymax = min(x[i*4+3], x[j*4+3]);
                //if (ymin > ymax) return Grad;

                double x_overlap = xmax-xmin;
                double y_overlap = ymax-ymin;

                // Gradient for xmin
                if (x[i*4] >= x[j*4] && x[i*4] != x[j*4+1] && x[i*4+1] 
!= x[j*4] && x[i*4+2] != x[j*4+3] && x[i*4+3] != x[j*4+2]) Grad[i*4] = 
Grad[i*4]-y_overlap;

                // Gradient for xmax
                if (x[i*4+1] < x[j*4+1]) Grad[i*4+1] = Grad[i*4+1] + 
y_overlap;

                // Gradient for ymin
                if (x[i*4+2] >= x[j*4+2] && x[i*4] != x[j*4+1] && 
x[i*4+1] != x[j*4] && x[i*4+2] != x[j*4+3] && x[i*4+3] != x[j*4+2]) 
Grad[i*4+2] = Grad[i*4+2]-x_overlap;

                // Gradient for ymax
                if (x[i*4+3] <= x[j*4+3]) Grad[i*4+3] = Grad[i*4+3] + 
x_overlap;

                // Gradient for xmax if rectangles are touching by the 
x-coordinate
                if (x[i*4+1] == x[j*4] && x[i*4+3] > x[j*4+2] && 
x[i*4+2] < x[j*4+3])
                {
                    Grad[i*4+1] = Grad[i*4+1] + y_overlap;
                }

                // Gradient for ymax if rectangles are touching by the 
y-coordinate
                if (x[i*4+3] == x[j*4+2] && x[i*4+1] > x[j*4] && x[i*4] 
< x[j*4+1])
                {
                    Grad[i*4+3] = Grad[i*4+3] + x_overlap;
                }
            }
        }
    }
    return Grad;
}


int main() {
    // Coordinates of the rectangles
    double x[] = {0,6,0,9,3,9,4,11};
    int n1 = sizeof(x)/32;

    double gradient;
    gradient = Gradient(x,n1);

    cout << "Gradient R1 xmin = " << Gradient[0] << endl;
}

Answer 1

Arrays are not first class elements in C++ language (they were not in C either). Specifically, when you pass an array to a function, or when you return it, it decays to a pointer to its first element. As the Grad array has automatic storage (neither static nor allocated) its lifetime ends at the end of a function and you only return a dangling pointer, meaning a pointer to a variable whose lifetime has ended. Using it is explicitely Undefined Behaviour.

In common implementation, automatic variables are allocated in the stack. So after the function returns, the memory pointed to by the dangling pointer is likely to be reused and what you will get will not be what you would expect. The segmentation fault is just one of the possible consequences of the UB.

The common way to return an array if you do not intend to use multi-threading would be to declare it static. That way its lifetime extends up to the end of the program and it solves the dangling pointer problem. That would be fine for a static size array (size defined at compile time) but not for a dynamic size (defined at run time). So you are left with 2 C-ish ways:

• use a dynamically allocated array (with new[] or malloc ); the caller will then have to free it (with resp. delete[] or free )
• let the caller manage the array and pass it to the function ( void Gradient(const double x[], double *Grad, int n1) ). This is the prefered way because the caller has full control over the allocation mode.

But in C++ the idiomatic way is to use a vector: std::vector Grad(n1*4, 0.); . A vector is a true C++ object and can be assigned or returned. Unless you have strong reasons to do so, avoid C-ish ways because C++ containers are much more programmer friendly.

Answer 2

I will try to help you

• variable-sized array double Grad [n1*4] = {0}; In C++, variable length arrays are not legal. G++ allows this as an "extension".
• return Grad; return pointer to local data, after exiting function Gradient Grad id not available

You can use std::vector , thus your code may look like this:

std::vector<double> Gradient(const double x[], int n1) {
    std::vector<double> Grad (n1*4, 0);
    ...
    Grad[i*4+3] = ...
    ...
    return Grad;
}

Answer 3

how can I return my array or write to a global variable

Read a good book on C++ programming, and look into this C++ reference .

 double* Gradient(const double x[], int n1) { double Grad [n1*4] = {0};

If n1 is a large positive integer such as 1234567, your code is likely to have a stack overflow . If n1 is negative, you are in trouble. AFAIK, VLA s are not in C++.

Read alsohow to debug small programs

You probably want to use some standard C++ container . std::array or std::vector comes to mind.

You can return some std::array<int,10> . Of course the computer would copy ten integers, and that is slower than returning just a pointer.

In some cases, you might want to use smart pointers . Read about the standard <memory> header .

Beware of buffer overflow and segmentation fault and other kinds of undefined behavior .

If you compile your C++ code with a recent GCC compiler, enable all warnings and debug info, so use g++ -Wall -Wextra -g . If you use GCC 10 , consider using the recently addedstatic analysis options. If you prefer Clang , consider using its static analyzer . Consider also using the Frama-C analyzer and reading this draft report. Be however aware of Rice's theorem .

In all cases read the documentation of your particular C++ compiler . Don't confuse your C++ compiler with your IDE or source-code editor . I suggest to compile on the command line, and use some build automation tool (perhaps GNU make or ninja ) with some version control tool such as git , and some debugger such as GDB . Tools like valgrind are also helpful.

Always avoid return ing the address of some automatic variable on the call stack . Once your function returned, that address is invalid. Be scared of uninitialized pointer variables.

Answer 4

There are multiple problems with your code.

1. You can't allocate the size of a static array at run time, that is you can't do this operation double Grad [n1*4] = {0}; where n1 is a variable. To allocate memory you have to use malloc function. ptr = (int*)malloc(n * sizeof(int)); where n is the size of desired array.A continuous block of memory will be allocated

2. Array can't be returned as such, to solve that problem pointers are introduced. If you follow the above method, ptr is a pointer which can access a memory location,while to access a particular element you can simple use ptr[i] , where i is the desired index

3. Gradient is a function, it's illegal to perform this operation Gradient[0] . I hope this have cleared your doubt. A simple tip try writing small block of code to check if certain thing works.