这是初始化指向结构的指针的正确方法吗？ 谢谢你

Question

how to create a pointer to struct the proper way?

typedef struct account{

char name[80];

int acct_year;

}account;

int main
{
account *accountant;// is this the proper way?
}

Answer 1

I wrote comments in the code to explain things. Let me know if still confusing.

#include <stdio.h>

// This is needed for strncpy
#include <string.h>

// This is needed for malloc
#include <stdlib.h>

struct Account {
    char name[80];
    int acct_year;
};

int main()
{
    // Normal declaration of a variable of type Account
    struct Account userAccount;


    // Using strncpy is safer than using strcpy. Read about overflow buffer attack.
    char* userName = "Alex";
    strncpy(userAccount.name, userName, sizeof(userName));
    
    userAccount.acct_year = 4;
    printf("User Account: %s %d\n", userAccount.name, userAccount.acct_year);
    
    // Creating a pointer to access the struct we declare and initiate above;
    struct Account *pUserAccount;
    
    // Pass the address of the variable above inside the pointer
    pUserAccount = &userAccount; 
    
    // We can replace the value in userAccount from the pointer
    pUserAccount->acct_year = 5; 
    
    // Compare to see that we changed the value in userAccount using the pointer
    printf("Pointer User Account: %s %d\n", pUserAccount->name, pUserAccount->acct_year);
    printf("User Account: %s %d\n", userAccount.name, userAccount.acct_year);
    
    
    // Let's create a pointer and give it some space from the Heap memory
    struct Account *pAdminAccount;
    pAdminAccount = malloc(sizeof (struct Account));
    
    // We always check because we could have run out of memory or something failed
    if (pAdminAccount != NULL) {
        // Due my lazyness, I am copying the name from userAccount inside pAdminAccount
        strncpy(pAdminAccount->name, userAccount.name, sizeof(userAccount.name));
        pAdminAccount->acct_year = 6;
        printf("Pointer Heap Adminr Account: %s %d\n", pAdminAccount->name, pAdminAccount->acct_year);
    
        // Always free the memory when you are not using it.    
        free(pAdminAccount);
    }
    
    return 0;
}

Note: I haven't done C in ages so double check what I am explaining here.

Explanation:

So, there are different ways that you can use a struct.

The first way to use is is like any other type such as int, char, bool, etc.

If I do int a; a = 4; int a; a = 4; , memory from the stack is provided that will be available inside the block it has being declared. So, if you create it inside a function, it will be available until you exit the function, even if you return the address of such variable using & . Don't do it.

So, struct Account userAccount; will create a variable that you can right away use it: userAccount.acct_year = 4;

If you wish to access indirectly using a pointer, then you need to create a pointer struct Account *pUserAccount; . In this pointer, is where we save the address of userAccount in this way: pUserAccount = &userAccount . Notices that I didn't use the * since we are not accessing.

The advantage of using this method is that the compiler knows the size of what we are pointing at. Later, when you are familiar with this, you can play with an array of structs and how to access them using pointers.

Anyways, continue with the explanation.

If you wish for example to have a function that creates an account and using such account outside a function, then you must use malloc . malloc fetch memory from the Heap and return an address to such memory location.

You must tell malloc how much memory you wish to reserve: sizeof (struct Account) .

As explained, malloc(sizeof (struct Account)); will return an address. Now, you can return that address from your function or use it right away.

Its important that you check for NULL since malloc might fail to get reserve memory (ie out of memory).

Also, its important for you to clean up after yourself. Free the memory you have taken in the Heap so other programs can use it too. This will prevent many issues such as memory segmentation and such.

You can declare it as struct Account userAccount; and automatically memory will be allocated in the whole life of the block. If the declaration of the

Answer 2

You have two options on how you Initialize a declared pointer. Take your example:

typedef struct account {
    char name[80];
    int acct_year;
} account;

int main (void)
{
    account *accountant;
}

Above, accountant is an Uninitialized pointer that holds an indeterminate (could be anything) address as its value. To initialize the pointer, you must either (1) assign the address of an existing type account to it, eg

int main (void)
{
    account account1 = { "Client A", 2019 };     /* object of type account */
    account *accountant = &account1;             /* address assigned to pointer */
    
    /* use accountant as needed */
    printf ("\naccountant: %s (%d)\n", accountant->name, accountant->acct_year);
}

Or, (2) dynamically allocate storage for accountant with malloc , calloc or realloc , eg

int main (void)
{
    account *accountant = malloc (sizeof *accountant);  /* allocate for 1 account */
    
    if (accountant == NULL) {                           /* validate every allocation */
        perror ("malloc-accountant");
        return 1;
    }
    
    strcpy (accountant->name, "Client A");
    accountant->acct_year = 2019;
    
    /* use accountant as needed */
    printf ("\naccountant: %s (%d)\n", accountant->name, accountant->acct_year);

    free (accountant);                                 /* free what you allocate */
}

Either way is fine. A pointer is simply a normal variable that holds the address where something else is stored in memory as its value. In other words, a pointer points to the address where something else can be found. You have to make sure that address the pointer holds as its value points to a valid memory address holding an object of that type. If you always ask "Where does my pointer point?" before using it -- you will never have trouble with pointers again.

Answer 3

The usual way is to use the malloc() system call to allocate a block of memory big nough for your structure type onto the system heap. You will want to check that actually happened in case you are out of memory.

    account * accountant;
    
    if ((accountant = malloc ( sizeof(struct account))) == NULL)
    {
              errno = ENOMEM;
              return some error token.
    }

...continue knowing the pointer has been initialised.

When you are finished MAKE SURE you free the block back to the system with

free (accountant);