This project has moved and is read-only. For the latest updates, please go here.


When programming, it is often convenient to have a single name with which to refer to a group of a related values. Structures provide a way of storing many different values in variables of potentially different types under the same name. This makes it a more modular program, which is easier to modify because its design makes things more compact. Structs are generally useful whenever a lot of data needs to be grouped together--for instance, they can be used to hold records from a database or to store information about contacts in an address book. In the contacts example, a struct could be used that would hold all of the information about a single contact--name, address, phone number, and so forth. 

The format for defining a structure is

struct Tag {

Where Tag is the name of the entire type of structure and Members are the variables within the struct. To actually create a single structure the syntax is

struct Tag name_of_single_structure;

To access a variable of the structure it goes


For example:

struct example {
  int x;
struct example an_example; /* Treating it like a normal variable type
                            except with the addition of struct*/
an_example.x = 33;          /*How to access its members */

Here is an example program:

struct database {
  int id_number;
  int age;
  float salary;

int main()
  struct database employee;  /* There is now an employee variable that has
                              modifiable variables inside it.*/
  employee.age = 22;
  employee.id_number = 1;
  employee.salary = 12000.21;

The struct database declares that it has three variables in it, age, id_number, and salary. You can use database like a variable type like int. You can create an employee with the database type as I did above. Then, to modify it you call everything with the 'employee.' in front of it. You can also return structures from functions by defining their return type as a structure type. For instance:

struct database fn();

I will talk only a little bit about unions as well. Unions are like structures except that all the variables share the same memory. When a union is declared the compiler allocates enough memory for the largest data-type in the union. It's like a giant storage chest where you can store one large item, or a small item, but never the both at the same time. 

The '.' operator is used to access different variables inside a union also. 

As a final note, if you wish to have a pointer to a structure, to actually access the information stored inside the structure that is pointed to, you use the -> operator in place of the . operator. All points about pointers still apply. 

A quick example:

#include <stdio.h>

struct xampl {
  int x;

int main()
    struct xampl structure;
    struct xampl *ptr;

    structure.x = 12;
    ptr = &structure; /* Yes, you need the & when dealing with 
                           structures and using pointers to them*/
    printf( "%d\n", ptr->x );  /* The -> acts somewhat like the * when 
                                   does when it is used with pointers
                                    It says, get whatever is at that memory
                                   address Not "get what that memory address

"Tutorial from by Alexander Allain. serves programming audiences with tutorials and articles on programming, along with free source code and an active message board." 

Last edited Sep 21, 2015 at 5:53 PM by vineetchoudhary, version 3