Passing a struct by reference instead of value within void functions - c

Question

I am trying to create a contact list using structures and functions. Currently my code compiles but the members of the struct are not being modified outside of the function like I am trying to do. Here is my code(removed some lines for length)
#include <stdio.h>
#include <stdlib.h>
struct ContactInfo
{
char fname[50];
char lname[50];
};
struct ContactInfo gc;
void getContactInfo(struct ContactInfo gc)
{
printf("First Name: ");
scanf("%s", gc.fname);
printf("\nLast Name: ");
scanf("%s", gc.lname);
}
void showContactInfo(struct ContactInfo gc)
{
printf("* First Name: %s \n", gc.fname);
printf("* Last Name: %s \n", gc.lname);
}
int main()
{
getContactInfo(gc);
showContactInfo(gc);
return 0;
}

Answer 1

For getContactInfo, you need to pass a pointer to the struct:
void getContactInfo( struct ContactInfo *gcptr )
{
printf("First Name: ");
scanf("%s", gcptr->fname);
printf("\nLast Name: ");
scanf("%s", gcptr->lname);
}
Since you're trying to modify the contents gc, you need to pass a pointer to it to the function. Remember that C passes all arguments by value, so the called function creates a separate, duplicate object that receives the value of the parameter. Your code is modifying that duplicate object, which has no effect on the actual parameter.
The -> operator is used when the operand is a pointer to a struct or union type - it implicitly dereferences the pointer before accessing the particular member. It's equivalent to writing (*gcptr).fname and (*gcptr).lname, while being a little easier on the eyes.
You'd call this function as
getContactInfo( &gc );
For showContactInfo, you can leave it as it is since you're not trying to modify the parameter. However, a lot of people like to pass pointers to structs to save memory (you're not building a copy of the struct in the called function). If you want to use a pointer, I would recommend using the const keyword like so:
void showContactInfo( const struct ContactInfo *gcptr )
{
printf("* First Name: %s \n", gcptr->fname);
printf("* Last Name: %s \n", gcptr->lname);
}
The const keyword tells the compiler to yell at me if I try to modify the contents of the object gcptr points to in the showContactInfo function. Like getContactInfo above, you'd call it as
showContactInfo( &gc );
Note that I changed the argument names to gcptr just to help distinguish between the formal argument in the function definition and the actual argument in the function call. I normally don't like putting any kind of type information in a variable or argument name, but you can use whatever naming convention you like.

Answer 2

The C way for doing this is just plain old pointers:
void showContactInfo(struct ContactInfo* gc)
{
printf("* First Name: %s \n", gc->fname);
printf("* Last Name: %s \n", gc->lname);
}
Other than having to use the arrow operator -> to access properties it's basically the same.
C itself does not have references like C++ does.

Answer 3

The getContactInfo function is supposed to return values, but you pass values in instead.
The most natural way to get data out of a function is to use the return value. Also you should not use global variables for passing data. The code could look like:
struct ContactInfo getContactInfo(void)
{
struct ContactInfo g = { 0 }; // ensure no garbage in case input fails
printf("First Name: ");
scanf("%49s", g.fname);
printf("Last Name: ");
scanf("%49s", g.lname);
return g;
}
with the code in main being:
struct ContactInfo gc = getContactInfo();
showContactInfo(gc);