C中的向量和矩阵

Question

I would like to perform vectorial operations in C but I don't know how to return a vector from a function. I tried to generate a vector in this way:

float *generate_vector()
{
    static float vec[3];
    return vec;  
}

However, calling this function using

int main (void)
{

  float vec[3];
  vec = generate_vector();

}

leads to an error (error: incompatible types when assigning to type 'float[3]' from type 'float *'). Interestingly, this error doesn't occur when only a component of the vector is called using vec[1] = &generate_vector()[1].

Could you help me with this problem?

Thank you in advance.

Answer 1

You have two problems here, the first is you can't assign an array like this:

vec = generate_vector();

Arrays decay to pointers when they're passed, but in the function where it's declared it's an array, and you can't assign a pointer to it like this.

You need to declare a pointer to get the returned array:

float *vec = generate_vector();

Just FYI, a second option you might be interested in, if you want to generate a new array from this function you can do it dynamically.

float *vec = malloc(3 * sizeof(float));

then you need to free that later when you're done.

Answer 2

Here's a different approach if you like. It's a little less efficient but might be easier to understand (and probably easier to handle in a complex program).

In C, you can't return an array. You either need to malloc() a buffer (which you need to keep track of and later free() it) or you need to declare a "return array" outside the function and pass an additional pointer to it into your functions.

So there is the inability to return an array. But hey, here is a nice workaround: you actually can return a struct that contains an array:

#include <stdio.h>

struct vec
{
    double v[3];
};  

struct vec multiply_scalar(struct vec v, double scalar)
{
    int i;
    struct vec ret;

    for (i = 0; i < 3; i++)
    {
        ret.v[i] = v.v[i] * scalar;
    }   
    return ret;
}   

Answer 3

As was mentioned you are returning a pointer so you need to assign it to a pointer variable. In addition, using a static array like this is a bad idea. It would be better to take the vector in like this:

void generate_vector(float * inVector)

This way the memory management is handled outside of the function and you won't accidentally use the same vector in multiple places.

With your setup a user of the function could write this code:

float * vectorA = generate_vector();
float * vectorB = generate_vector();

They may not expect that vectorA and vectorB are actually the same thing and this would lead to bugs.

Answer 4

When doing these things in C, I tend to reserve the return value of a function for an indicator that a function has succeded or failed. The input and output arrays I tend to pass as parameters.

Some years ago I wrote a Perl script to generate loop-unrolled matrix and vector code. (Like C++ templates, but for C) An example of the output is this function to transform a vector with a matrix.

/* Multiplies a matrix with a vector */
extern void mat_xform3(double m[3][3], double v[3], double mv[3]);

Implementation:

#ifndef NULL
#define NULL (void*)0
#endif

/* If the product of the multiplication of two doubles is less than EPS,
 * the value is set to 0. */
#define EPS 1e-8

void mat_mul3(double a[3][3], double b[3][3], double ab[3][3])
{
        double res[3][3];
        assert(a!=NULL); assert(b!=NULL); assert(ab!=NULL);
        res[0][0]  = a[0][0]*b[0][0];
        res[0][0] += a[0][1]*b[1][0];
        res[0][0] += a[0][2]*b[2][0];
        if (res[0][0] < EPS && res[0][0] > -EPS) {res[0][0] = 0.0;}
        res[0][1]  = a[0][0]*b[0][1];
        res[0][1] += a[0][1]*b[1][1];
        res[0][1] += a[0][2]*b[2][1];
        if (res[0][1] < EPS && res[0][1] > -EPS) {res[0][1] = 0.0;}
        res[0][2]  = a[0][0]*b[0][2];
        res[0][2] += a[0][1]*b[1][2];
        res[0][2] += a[0][2]*b[2][2];
        if (res[0][2] < EPS && res[0][2] > -EPS) {res[0][2] = 0.0;}
        res[1][0]  = a[1][0]*b[0][0];
        res[1][0] += a[1][1]*b[1][0];
        res[1][0] += a[1][2]*b[2][0];
        if (res[1][0] < EPS && res[1][0] > -EPS) {res[1][0] = 0.0;}
        res[1][1]  = a[1][0]*b[0][1];
        res[1][1] += a[1][1]*b[1][1];
        res[1][1] += a[1][2]*b[2][1];
        if (res[1][1] < EPS && res[1][1] > -EPS) {res[1][1] = 0.0;}
        res[1][2]  = a[1][0]*b[0][2];
        res[1][2] += a[1][1]*b[1][2];
        res[1][2] += a[1][2]*b[2][2];
        if (res[1][2] < EPS && res[1][2] > -EPS) {res[1][2] = 0.0;}
        res[2][0]  = a[2][0]*b[0][0];
        res[2][0] += a[2][1]*b[1][0];
        res[2][0] += a[2][2]*b[2][0];
        if (res[2][0] < EPS && res[2][0] > -EPS) {res[2][0] = 0.0;}
        res[2][1]  = a[2][0]*b[0][1];
        res[2][1] += a[2][1]*b[1][1];
        res[2][1] += a[2][2]*b[2][1];
        if (res[2][1] < EPS && res[2][1] > -EPS) {res[2][1] = 0.0;}
        res[2][2]  = a[2][0]*b[0][2];
        res[2][2] += a[2][1]*b[1][2];
        res[2][2] += a[2][2]*b[2][2];
        if (res[2][2] < EPS && res[2][2] > -EPS) {res[2][2] = 0.0;}
        memcpy(ab, res, 3*3*sizeof(double));
}

In this case, the function cannot fail, so it returns void . But a function to eg invert a matrix can fail, so that returned a value indicating success or failure.

The Perl script could generate code for matrices of arbitrary size. Leave a comment if you'd want it.