Thread: malloc in function

Originally Posted by mugen

Code:

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

void func(int **tmp, int n);

int main(void){
    int **ptr;
    func(ptr, 8);
    ptr[2][4] = 1;
    getchar();
    return 0;
}

void func(int **tmp, int en){
    int i;
    tmp = malloc(en * sizeof(int));
    for (i = 0; i < en; i++)
        tmp[i] = malloc( en * sizeof(int));
}

Hey,

first of all, in C you _NEVER_ call by reference. C only allows to call-by-value. Call-by-reference is an enhancement in C++.

This is how your code should work:

Code:

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

void func(int ***tmp, int n);

int main(void){
    int **ptr;
    func(&ptr, 8);
    ptr[2][4] = 1;
    getchar();
    return 0;
}

void func(int ***tmp, int en){
    int i;
    *tmp = (int**)malloc(en * sizeof(int *));

    for (i = 0; i < en; i++)
        (*tmp)[i] = (int*)malloc( en * sizeof(int));
}

I hope that is what you're searching for ...

- Andi -

This will fix it.

I'd advise you to ignore using three stars. Who's gonna read that code?

Code:

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

int **func(int **tmp, int n);

int main(void){
    int **ptr;
    ptr = func(ptr, 8);
    ptr[2][4] = 25;
    getchar();
    return 0;
}

int **func(int **tmp, int en){
    int i;
    tmp = (int **) malloc(en * sizeof(*tmp));
    for (i = 0; i < en; i++)
        tmp[i] = (int *) malloc( en * sizeof(tmp));
    return tmp;
}

Gotta return adress to ptr.

Also, add checking for error - malloc could fail. If it fails return NULL.

And ignore my casting (int **). I got a crapy compiler.

Can be done much easier and logical using the method i mentioned above.

Sure, you can do it that way aswell - but i'd say its bad style.

Originally Posted by ForzaItalia2006

In turn, if you pass the variable by-pseudo-reference in C (because call-by-reference does not exists as in C++)

This is a little bit semantic since languages other than C++ also use references, some of them differently, but there is no point in saying "compared to language X, C++ uses pass by pseudo-reference, since these kinds of references are not quite the same").

Going by concept, it does make sense to discuss passing an address (&) as a "pass by reference" technique, just don't use the term in an exam answer.

I think the 3-star guideline is not simply about style but also form: if you find yourself needing to do this, it's probably because your functions are not modular enough. If a function does one thing well, it can use the return value. It hard to conceive of a situation where you need to pass in a 2D pointer, reassign it, and use the return value for some other purpose.

Three stars isn't any harder to understand than two. Or four, for that matter. If I have type X, I need a pointer to that type, if I'm going to change the value of it when I pass it to a function. That's all. It's the same if you want to change an int, or a pointer to an int, or a pointer to a pointer to a pointer to an int.

Whatever it is, if you want to change its value, you need a pointer to it.


Quzah.

Originally Posted by quzah

Three stars isn't any harder to understand than two. Or four, for that matter. If I have type X, I need a pointer to that type, if I'm going to change the value of it when I pass it to a function. That's all. It's the same if you want to change an int, or a pointer to an int, or a pointer to a pointer to a pointer to an int.

See this discussion on Three Star Programmers. I pretty much agree with MK27, though not so much in terms of modularity of functions, but in terms of abstraction. It is not difficult to understand three levels of indirection when you understand even just one level of indirection, but using three or more levels of indirection often indicates a failure to apply an abstraction appropriately.

Code:

matrix = makematrix( X, Y );

Or...

Code:

makematrix( &matrix, X, Y );

...both are clear as to what they do. There's not really much difference. Inside the function it may be a bit ugly. But it doesn't have to be:

Code:

void makematrix( type ***m, size_t x, size_t y )
{
    type **t;

    t = malloc( sizeof(*t) * y );
    if( t )
    {
        size_t row = y;
        while( row-- )
        {
            t[ row ] = malloc( sizeof( **t ) * x );
        }
        *m = t;
    }
}

That looks about right, I've been up forever. But you don't really need to actually use the third star for anything, and still be able to pass the address of a double star. (edit: bugfix with x/y-- to row-- [Z_Z])


Quzah.