Thread: Passing structure by reference through 4 functions

Hi there,

I have the following code, listed below. Basically I need to pass a structure by reference through 4 functions so that I can change its value in the fourth function and then keep the changed value up to the top.

The following code is not working (C, Linux). Any help on that would be greatly appreciated.

Code:

#include "main.h"

void f1(struct list_type **info)
{
	(*info)->type = 1;
	strcpy((*info)->data, "1");

	f2(&(*info));
}

void f2(struct list_type ***info)
{
	(**info)->type = 2;
	strcpy((**info)->data, "2");

	f3(&(**info));
}

void f3(struct list_type ****info)
{
	(***info)->type = 3;
	strcpy((***info)->data, "3");

	f4(&(***info));
}

void f4(struct list_type *****info)
{
	(****info)->type = 4;
	strcpy((****info)->data, "4");
}

int main(int argc, char **argv)

{
	struct list_type *info = NULL;
	
	info->data = malloc(sizeof(char) * 100);
	if (info->data == NULL)
		return 1;

	info->type = 0;
	strcpy(info->data, "0");

	f1(&info);

	free(info->data);

	return 0;

}

Thank you very much.

Regards,
Nick

There's no need for extra stars as you go along. And you should define "not working".

Originally Posted by claudiu

1) I don't know why you would ever want to do something like this.

Well... unfortunately it isn't a learning experiment. I wrote a good chunk of code with f1 using a complex version of the structure then passing it to f2(), with the data from structure being read in f3() then in a shared library with additional processing in f4(). After return from f4->f3->f2 to f1 I found out that the structure data was changed locally in f4() only.

Could you please provide a more explicit answer for f1 and f2 at least.

Thank you very much.

Originally Posted by nickdavid35

Well... unfortunately it isn't a learning experiment. I wrote a good chunk of code with f1 using a complex version of the structure then passing it to f2(), with the data from structure being read in f3() then in a shared library with additional processing in f4(). After return from f4->f3->f2 to f1 I found out that the structure data was changed locally in f4() only.

Could you please provide a more explicit answer for f1 and f2 at least.

Thank you very much.

There's still no need for extra stars as you go along -- a reference to a structure is always and forever "struct list_info *". (If you need to make the pointer point to a different structure -- i.e., if you do malloc/or realloc -- then you need to pass the pointer by reference, which would be "struct list_info **".)

Originally Posted by tabstop

There's no need for extra stars as you go along. And you should define "not working".

By not working I mean that when I am changing the structure data in f4() the data is changed only locally, it is not "brought back with the new values" to main().

Thank you very much.

I can not use the struct as a return value from f4() or f3() or f2() or f1() as well. I have close to 170 shared libraries all built in the same way, it would be a major effort to rewrite that. I tested some initially, but I did some bad allocations in f4() and valgrind pointed that the memory was leaking.

I can pay $50 for that if someone is willing to help me make it work.

No really:

Code:

#include <stdio.h>

struct thing {
    int x;
};

void f4(struct thing *bob) {
    bob->x = 5;
}

void f3(struct thing *bob) {
    f4(bob);
}

void f2(struct thing *bob) {
    f3(bob);
}

void f1(struct thing *bob) {
    f2(bob);
}

int main(void) {
    struct thing foo;
    foo.x = 2;
    printf("Before: %d\n", foo.x);
    f1(&foo);
    printf("After: %d\n", foo.x);
    return 0;
}

And the version where the function needs to acquire space:

Code:

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

struct thing {
    int x;
};

void f4(struct thing **bob) {
    *bob = malloc(sizeof(**bob));
    (*bob)->x = 5;
}

void f3(struct thing **bob) {
    f4(bob);
}

void f2(struct thing **bob) {
    f3(bob);
}

void f1(struct thing **bob) {
    f2(bob);
}

int main(void) {
    struct thing *foo;
    foo = NULL;
    printf("Before: %x\n", foo);
    f1(&foo);
    printf("After: %x and value %d\n", foo, foo->x);
    return 0;
}

[QUOTE=tabstop;942397]No really:

Code:

#include <stdio.h>

struct thing {
    int x;
};

Thank you very much TabStop. How can I send you the funds?

Thank you also Claudiu.

Final working code, reference for some other people:

Code:

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

struct thing {
    int x;
	char *y;
};

void f4(struct thing *bob) {
    bob->x = 4;
	strcpy(bob->y, "4");
    printf("4: %d, %s\n", bob->x, bob->y);
}

void f3(struct thing *bob) {
    bob->x = 3;
	strcpy(bob->y, "3");
    printf("3A: %d, %s\n", bob->x, bob->y);

    f4(bob);
    printf("3B: %d, %s\n", bob->x, bob->y);
}

void f2(struct thing *bob) {
    bob->x = 2;
	strcpy(bob->y, "2");
    printf("2A: %d, %s\n", bob->x, bob->y);

    f3(bob);
    printf("2B: %d, %s\n", bob->x, bob->y);
}

void f1(struct thing *bob) {
    bob->x = 1;
	strcpy(bob->y, "1");
    printf("1A: %d, %s\n", bob->x, bob->y);

    f2(bob);
    printf("1B: %d, %s\n", bob->x, bob->y);
}

int main(void) {
    struct thing foo;
	foo.y = malloc(100);

    foo.x = 0;
    strcpy(foo.y, "0");
    printf("0A: %d, %s\n", foo.x, foo.y);
    f1(&foo);
    printf("0B: %d, %s\n", foo.x, foo.y);
	free(foo.y);
    return 0;
}