Thread: Need help with returning pointer from function

One option is to change the function to take a pointer to a Coordinate instead of having a static local variable. If that is not feasible, you could write a wrapper:

Code:

void Read_XTP2046_Into(Coordinate *coordinate)
{
    Coordinate *result = Read_XTP2046();
    coordinate->x = result->x;
    coordinate->y = result->y;
}

/* ... */

Coordinate cor;
Read_XTP2046_Into(&cor);

You could also make use of memcpy for your wrapper since the struct does not have any pointer members that need to be handled separated anyway, but that's up to you.

As @laserlight stated you could pass the struct as a parameter, but sometimes I had a habit to not do so. I don't know maybe because Its not exotic.
You can use malloc:

Code:

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


struct x
{
    int member;
};


struct x* foo ()
{
    struct x* internalStruct = malloc(sizeof(struct x));


    internalStruct->member = 1;


    return internalStruct;
}


int main()
{
    struct x* ptr = foo();


    printf("%i", ptr->member);


    return 0;
}

Or you can use your struct as an array of members:

Code:

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


struct x
{
    int member;
};


struct x* foo ()
{
    static struct x internalStruct[] = {1};


    return internalStruct;
}


int main()
{
    struct x* ptr = foo();


    printf("%i", ptr->member);


    return 0;
}

Same thing. Array decays to a pointer to the first element. Structure is the same thing alrady. Thats one of the reasons why they are considered very similar.

Originally Posted by Al3

You can use malloc:

This could be a good choice if you intend to use Read_XTP2046 as the init function for your Coordinate interface. On the other hand, you should free what you malloc, and you might not always want to use malloc.

Originally Posted by Al3

Or you can use your struct as an array of members:

This approach has the same pitfall as your current approach: you still have a static local variable, so you can only ever have one Coordinate object unless you make a copy, and if you do not keep this in mind, you might end up overwriting a Coordinate object that you thought was a different object.

Originally Posted by Al3

Most of the recent compilers afaik free automatically allocated space on terminating.

It isn't so much the compiler as the operating system, i.e., memory allocated for a process would be cleaned up when the process is terminated, even if the dynamically allocated memory was not deallocated prior to termination. However, relying on this can develop a bad habit since as you noted this is not proper garbage collection.

Originally Posted by Al3

I thought he wants to modify and return a struct from a function.

I think Hectickz wants to populate the cor variable using Read_XTP2046. If the aim is to modify an existing object, then the static local variable, whether as a lone object or as an array of one element, and the use of malloc, are both bad choices.

Originally Posted by Al3

One of the worst ways is doing that directly.

What do you mean?

Yes, the system deallocates. But also the compiler is optimized to throw-out. Everything is lowered in the object file.

I though he just want to take modify and return a struct pointer, noting he has his reason for returning a structure pointer instead of just structure.
And yeah. He can do that with dynamic or static allocated pointer. If he don't do that he is fated of u/b (most certainly crash)

I meant this:

Code:

(*(int *)structure+sizeof(int))

Assuming

• The structure member is type int

• 2. There are no padding bytes (Use #pragma pack if there are)

Hi all! thanks for the fast replies!

Maybe some more information is in order.
The Read_XTP2046() function reads the x and y value from the touchscreen which are analysed by the XTP2046 chip. So these variables change every time whenever I press the screen. I will try the wrapper as it seems the most easiest way to achieve my goal, simply reading were I press the screen.

I need to add that I am clearly outskilled by all of you, and that I am not familiar with memcpy or malloc. I only program microcontrollers and this is for the LPC1788 ARM chip interfacing with an TFT LCD touch display.

So long as you always know about the "must make a copy" part of the restrictions, then having a static local works well enough (see such functions as asctime(), which do the same thing).

In your caller function, you do this.
Coordinate cor;
cor = *Read_XTP2046();

But you can save yourself at least one restriction on calling the function, by returning the structure by value.
Eg.

Code:

Coordinate Read_XTP2046(void)
{
    Coordinate screen; 
    //calculations to determine the coordinates 
    screen.x=(temp[1]+temp[2])/2; 
    screen.y=(temp[0]+temp[2])/2; // and so on... 
    return screen;
}

int main ( ) {
    Coordinate cor;
    cor = Read_XTP2046();
}

For a small struct with only a couple of members, the compiler will likely optimise away a lot of the apparent effort.