[SOLVED] Struct pointer *ptr = *ptr ?

errigour · 02-11-2014, 03:19 AM

What does the line swap = *obj do exactly and also the line *obj = *refobj.

Code:

struct obj_data *refobj
struct obj_data *obj, swap;

swap = *obj;
*obj = *refobj;

mina86 · 02-11-2014, 06:58 AM

Recursively copy fields of struct obj_data from *obj to swap. In some sense, it's similar to memcpy(&swap, obj, sizeof swap);

sundialsvcs · 02-11-2014, 07:51 AM

There would, of course, have to be a third line in that example, to finish the thought:

*refobj = swap;

These are simple assignment-statements; nothing "recursive" about it. (C is not that clever.) A block of memory (referenced by a pointer) is copied to a temporary location (which is local), then it is assigned from a location referenced by a second pointer. Then, presumably, the second location will next be assigned from the temporary. Thus swapping the content of the two locations.

rtmistler · 02-11-2014, 08:06 AM

Interesting expansion of that. Where is it taking the memory to perform that? I.e. if one wishes to not use as much stack, they could code it as: (Providing obj and refobj were properly initialized that is)

Code:

struct obj_data *refobj, *obj, *swap;

obj = <passing argument 1>
refobj = <passing argument 2>
*swap = *obj;
*obj = *refobj;
*refobj = *swap

That all valid? And if so, where does it take memory to do this from? The heap? What happens if an obj_data is so large that you'll run out of memory?

NevemTeve · 02-11-2014, 08:26 AM

Segfaults. Fix:

Code:

struct obj_data *refobj, *obj, swap;

obj = <passing argument 1>
refobj = <passing argument 2>
swap = *obj;
*obj = *refobj;
*refobj = swap

rtmistler · 02-11-2014, 08:31 AM

Yeah, you're right I should've tried the code before suggesting it. My question really was where the memory comes from, but now it appears the answer is that you have to have at least one place to put it; in this case on the stack. If one desires a non-stack option, then they would have to either scope swap higher than the function or allocate *swap from within the function.

mina86 · 02-11-2014, 10:08 AM

Quote:

Originally Posted by sundialsvcs

These are simple assignment-statements; nothing "recursive" about it.

By recursive I meant that assigning one structure to another is equivalent, apart from potential differences in padding bytes, to assigning each member of the structure to corresponding member of the other structure. If such a member is structure itself, this rule is applied recursively.

Compilers end up doing equivalent of memcpy, even though I think they would be allowed not to copy padding bytes.

sundialsvcs · 02-11-2014, 10:12 PM

... and the reason why I sought to very-politely correct you on that point is ... "C" is just not that smart. To "C," a structure is a contiguous block of memory; nothing more or less. It's exactly like a simple scalar variable, only bigger. (Recall that "C" doesn't even have a proper notion of a "string," only pchar.)

So, in C, if you assign something to something-else, a contiguous range of bytes gets copied verbatim from here to there; nothing more or less. Hence, no opportunity for "recursion," which implies deep-knowledge of what the contents of the structure actually represent. Which is exactly what other languages, including C++, can do. In "C," it's just an overglorified memcpy().

In the case at bar, the temporary, being a local variable, lives on the stack. The other blocks of storage are accessed by means of pointers which also live on the stack.

errigour · 02-11-2014, 10:55 PM

Ok thanks.

mina86 · 02-12-2014, 06:27 AM

Quote:

Originally Posted by sundialsvcs

So, in C, if you assign something to something-else, a contiguous range of bytes gets copied verbatim from here to there; nothing more or less. Hence, no opportunity for "recursion," which implies deep-knowledge of what the contents of the structure actually represent. Which is exactly what other languages, including C++, can do. In "C," it's just an overglorified memcpy().

This is clearly not true:

Code:

long long a;
unsigned char b;
b = a;
a = b;

Here's a relevant portion of the C99 standard:

Quote:

Originally Posted by ISO/IEEC 9899:TC3

§6.5.16.1¶2 In simple assignment (=), the value of the right operand is converted to the type of the assignment expression and replaces the value stored in the object designated by the left operand.

Performing a conversion implies understanding of the type.

psionl0 · 02-13-2014, 03:29 AM

Quote:

Originally Posted by NevemTeve

Segfaults. Fix:

Code:

struct obj_data *refobj, *obj, swap;

obj = <passing argument 1>
refobj = <passing argument 2>
swap = *obj;
*obj = *refobj;
*refobj = swap

Quote:

Originally Posted by rtmistler

Yeah, you're right I should've tried the code before suggesting it. My question really was where the memory comes from, but now it appears the answer is that you have to have at least one place to put it; in this case on the stack. If one desires a non-stack option, then they would have to either scope swap higher than the function or allocate *swap from within the function.

The memory came from the calling function. <passing argument 1> and <passing argument 2> are pointers to the memory used by the calling function which this function refers to to do the swapping. So the memory could have been on the stack, heap or static data depending on how the calling function chose to allocate the memory.

(Note that swap was allocated on the stack by this function).

NevemTeve · 02-13-2014, 03:39 AM

Note: when a function wants to use (possibly large amount) of local data, it might do it this way:

Code:

void foo (size_t amount)
{
    char local [256], *allocated= NULL, *used= local;

    if (amount > sizeof (local)) {
        allocated= malloc (amount);
        if (!allocated) exit (111);
        used= allocated;
    }
    ...
RETURN:
    used= NULL;
    if (allocated) {
        free (allocated);
        allocated= NULL;
    }
}