Thread: Struct as pointers

Greetings.

I seek assistance with gaining an understanding of structs in the case when they are passed as pointers to function. Below are code snippets to illustrate my points of contention:

Code:

typedef struct stack_t Stack;

struct stack_t{
  int * data; 
  int top;              //points to top of the *data
}

I define & initialize the struct as follows:

Code:

Stack stk;
Stack * S = &stk;
init(S, 3);

It is as this point when I initialize the struct that my understanding of the subject leads me to attempt the following method, which results in compiler errors. The definition of init() is as follows:

Code:

void init(Stack * S, int N){
   int * stk = (int*)malloc(N*sizeof(int));
   stk = &(S->data);                                   //Causes error
   S->top = -1;
}

Would greatly appreciate assistance with addressing the above concern.

Look forward to a prompt response.

Best regards,
wirefree101

In the future, please show the actual errors you get; they are much more helpful than simply saying you got an error.

This case, though, I can eyeball easily. stk is a pointer to int. &S->data is a pointer to pointer to int. These are not the same thing and cannot be used interchangeably. For this case, I see no particular reason why you are even using a temporary variable at all. Why not:

Code:

S->data = malloc(N * sizeof *S->data);

This, I imagine, is what you're trying to do. In your code, I presume you have the assignment turned around; that is, you want to assign stk to S->data, not the other way around.

Originally Posted by wirefree101

Greetings.

I seek assistance with gaining an understanding of structs in the case when they are passed as pointers to function. Below are code snippets to illustrate my points of contention:

Code:

typedef struct stack_t Stack;

struct stack_t{
  int * data; 
  int top;                 //points to top of the stack data
}

Shouldn't the struct definition be the other way around as top is not a pointer it can't point to the top of *data ie

Code:

struct stack_t
{
  int data; 
  int *top;
}

Given the above struct definition, top can now point to the top of the data stack.

Originally Posted by wirefree101

I define & initialize the struct as follows:

Code:

Stack stk;
Stack * S = &stk;
init(S, 3);

It is as this point when I initialize the struct that my understanding of the subject leads me to attempt the following method, which results in compiler errors. The definition of init() is as follows:

Code:

void init(Stack * S, int N){
   int * stk = (int*)malloc(N*sizeof(int));
   stk = &(S->data);                                   //Causes error
   S->top = -1;
}

Once again stuff seems to be switched around, as in

Code:

   int * stk = (int*)malloc(N*sizeof(int));
   //stk = &(S->data);    // no can't do as cas noted besides you're initializing S not stk
   S->top = stk;
   S->data = -1;

Code:

stk = (S->data);

stk is pointing to s-> next

Greetings.

I seek assistance with understanding the usage of pointer to a pointer in cases where struct is employed. I state my point of contention with the help of the following illustrative code:

Code:

int main(){
   Node *ptr = NULL;       //pointer to struct Node
   initialize(&ptr);
}

void initiatize(** ptrN){
   if(*ptrN == NULL)
      ...                  //code to initialize struct elements
      ...
}

My query is the following:

Qs.: What has been achieved that differs from the case where I call initialize(ptr) (not initialize(&ptr)) and initialize() receives (*ptrN) (not (**ptrN))?

Would greatly appreciate a simply stated & prompt response.

Best regards,
wirefree101

Originally Posted by vart

replace the Node* type with int and follow the code

Appreciate the responses.

As suggested, I submit the following code for your comments.

Synopsis: Two functions perform the addition operation - first receives a pointer to a pointer while the second receives simply a pointer. They both achieve the desired addition operation. The detail is for the sake of completion.

Code:

void addI(int **j){
	printf("%d\n",j);	// pointer's address
	printf("%d\n",*j);	// i's address
	printf("%d\n",**j);	// i
	**j = **j + 1; 			//store at this address the content of this address added to 1
	printf("---%d\n",*j);	
}

void addX(int *j){
	printf("%d\n",j);	//x's address
	printf("%d\n",*j);   //x
	*j = *j + 1; 			//store at this address the content of this address added to 1
}


int main(){
	int i = 5;
	int * ptrI = &i;
	printf("%d\n",ptrI);	//address stored by pointer i.e. i's address
	printf("%d\n",&ptrI);//pointer's own address
	printf("%d\n",*ptrI);//value at address stored by pointer i.e. i
	addI(&ptrI);
	printf("i=%d\n",i);
	
	int x = 5;
	int * ptrX = &x;
	addX(ptrX);
	printf("x=%d\n",x);
	
	return 0;
}

Would appreciate your comments (corrections) against each of my comments in the code. The same would assist my understanding.

Best regards,
wirefree101