How to handle the assignment operation for structures with pointers? - c

Question

I have a structure definition which I need to control the assignment operator for. Here is some example code that doesn't work how I want yet.
struct jsonobject {
struct jsonobject* children[100];
};
int main(int argc, const char * argv[]) {
struct jsonobject obj;
struct jsonobject obj2;
obj2 = obj; // Problem is here.
return 0;
}
The issue is that the line obj2 = obj performs a shallow copy of the obj when I need it to perform a deep copy. How am I supposed to handle cases like this?

Answer 1

memcpy(&obj2, &obj, sizeof obj) like obj2 = obj in this example creates a shallow copy (if your object contains pointers those are copied not whatever they pointer to).
You will need a (custom) function to create a deep copy. You will probably want to store number of children in your struct unless you use a sentinel (NULL).
JSON libraries ship with suitable functions, and usually, a mechanism to share data via reference counts.

Answer 2

You can write your own function which performs the deep copy recursively. Here is a demonstration which allocates memory for the copy using malloc:
#include <stdio.h>
#include <stdlib.h>
#define MAX_CHILDREN 5
struct jsonobject {
struct jsonobject* children[MAX_CHILDREN];
};
void deep_print( const struct jsonobject *obj );
struct jsonobject *deep_copy( const struct jsonobject *src );
void deep_free( struct jsonobject *obj );
int main( void )
{
//construct jsonobject with two layers of children
struct jsonobject child3child1 =
{
{
NULL,
NULL,
NULL,
NULL,
NULL
}
};
struct jsonobject child1 =
{
{
NULL,
NULL,
NULL,
NULL,
NULL
}
};
struct jsonobject child3 =
{
{
NULL,
&child3child1,
NULL,
NULL,
NULL
}
};
struct jsonobject root =
{
{
NULL,
&child1,
NULL,
&child3,
NULL
}
};
//deep print the source data
printf( "Deep print of source data: \n\n" );
deep_print( &root );
//perform the deep copy
struct jsonobject *copy = deep_copy( &root );
//deep print the copied data
printf( "\n\nDeep print of copied data: \n\n" );
deep_print( copy );
//cleanup
deep_free( copy );
}
void deep_print( const struct jsonobject *obj )
{
// NOTE: This function is not thread-safe, because of the use
// of this static variable.
static int depth = 0;
for ( int i = 0; i < MAX_CHILDREN; i++ )
{
//add indentation according to depth
for ( int j = 0; j < depth; j++ )
printf( "----" );
if ( obj->children[i] == NULL )
{
printf( "children[%d] is NULL\n", i );
}
else
{
printf(
"children[%d] points to %p which contains the following:\n",
i, (void*)obj->children[i]
);
depth++;
deep_print( obj->children[i] );
depth--;
}
}
}
struct jsonobject *deep_copy( const struct jsonobject *src )
{
//allocate memory for new struct
struct jsonobject *new_struct = malloc( sizeof *new_struct );
if ( new_struct == NULL )
{
fprintf( stderr, "Memory allocation failure!\n" );
exit( EXIT_FAILURE );
}
//recursively copy all children
for ( int i = 0; i < MAX_CHILDREN; i++ )
{
if ( src->children[i] == NULL )
{
new_struct->children[i] = NULL;
}
else
{
//perform a recursive deep copy
new_struct->children[i] = deep_copy( src->children[i] );
}
}
return new_struct;
}
void deep_free( struct jsonobject *obj )
{
for ( int i = 0; i < MAX_CHILDREN; i++ )
{
if ( obj->children[i] != NULL )
{
deep_free( obj->children[i] );
}
}
free( obj );
}
For demonstration purposes, I reduced MAX_CHILDREN from 100 to 5. For the code in your question, you want MAX_CHILDREN to have the value 100.
This demonstration program has the following output:
Deep print of source data:
children[0] is NULL
children[1] points to 0x7ffc58161500 which contains the following:
----children[0] is NULL
----children[1] is NULL
----children[2] is NULL
----children[3] is NULL
----children[4] is NULL
children[2] is NULL
children[3] points to 0x7ffc58161550 which contains the following:
----children[0] is NULL
----children[1] points to 0x7ffc581614b0 which contains the following:
--------children[0] is NULL
--------children[1] is NULL
--------children[2] is NULL
--------children[3] is NULL
--------children[4] is NULL
----children[2] is NULL
----children[3] is NULL
----children[4] is NULL
children[4] is NULL
Deep print of copied data:
children[0] is NULL
children[1] points to 0x604000000050 which contains the following:
----children[0] is NULL
----children[1] is NULL
----children[2] is NULL
----children[3] is NULL
----children[4] is NULL
children[2] is NULL
children[3] points to 0x604000000090 which contains the following:
----children[0] is NULL
----children[1] points to 0x6040000000d0 which contains the following:
--------children[0] is NULL
--------children[1] is NULL
--------children[2] is NULL
--------children[3] is NULL
--------children[4] is NULL
----children[2] is NULL
----children[3] is NULL
----children[4] is NULL
children[4] is NULL
As you can see, the structure of the source data was successfully copied. Also, the addresses of the children of the copied data are different to those of the source data. This proves that a deep copy, not a shallow copy, was performed.