Section 3.5 Structures

Data structures.

struct model_name {
  type1 element1;
  type2 element2;
  type3 element3;
  .
  .
} object_name;

If the structure definition includes the parameter model_name (optional), that parameter becomes a valid type name equivalent to the structure. For example:

struct products {
  char name [30];
  float price;
} ;

products apple;
products orange, melon;

Once declared, products has become a new valid type name like the fundamental ones int, char or short. And since then we have been able to declare objects (variables) of that type.

The optional field object_name that can go at the end of the structure declaration serves to directly declare objects of the structure type. For example, to declare the structure objects apple, orange and melon like we have done previously we could also have done it this way:

struct products {
  char name [30];
  float price;
} apple, orange, melon;

It is important to clearly differentiate between what is a structure model, and what a structure object. Using the terms we used with variables, the model is the type, and the object is the variable. We can instantiate many objects (variables) from a single model (type).

Once we have declared our three objects of a determined structure model (apple, orange and melon) we can operate with the fields that compose them. For that we have to use a point (.) inserted between the object name and the field name. For example, we could operate with anyone of these elements as if they were standard variables of their respective types:

apple.name
apple.price
orange.name
orange.price
melon.name
melon.price

We are going to leave apples, oranges and melons and go with an example about movies:

// example about structures
#include <iostream.h>
#include <string.h>
#include <stdlib.h>

struct movies_t {
  char title [50];
  int year;
} mine, yours;

void printmovie (movies_t movie);

int main ()
{
  char buffer [50];

  strcpy (mine.title, "2001 A Space Odyssey");
  mine.year = 1968;

  cout << "Enter title: ";
  cin.getline (yours.title,50);
  cout << "Enter year: ";
  cin.getline (buffer,50);
  yours.year = atoi (buffer);

  cout << "My favourite movie is:\n ";
  printmovie (mine);
  cout << "And yours:\n ";
  printmovie (yours);
  return 0;
}

void printmovie (movies_t movie)
{
  cout << movie.title;
  cout << " (" << movie.year << ")\n";
}

The example shows how can we use the elements of a structure and the structure itself as normal variables. For example, yours.year is a valid variable of type int, as well as mine.title is a valid array of 50 chars.

Notice that either mine and yours are also treated as valid variables of type movie_t when being passed to the function printmovie(). Therefore, one of the most important advantages of structures is that we can refer either to their elements individually or to all the structure as a block.

Structures are a very used feature to build data bases, specially if we consider the possibility to build arrays of them.

// array of structures
#include <iostream.h>
#include <stdlib.h>

#define N_MOVIES 5

struct movies_t {
  char title [50];
  int year;
} films [N_MOVIES];

void printmovie (movies_t movie);

int main ()
{
  char buffer [50];
  int n;
  for (n=0; n<N_MOVIES; n++)
  {
    cout << "Enter title: ";
    cin.getline (films[n].title,50);
    cout << "Enter year: ";
    cin.getline (buffer,50);
    films[n].year = atoi (buffer);
  }
  cout << "\nYou have entered these movies:\n";
  for (n=0; n<N_MOVIES; n++)
    printmovie (films[n]);
  return 0;
}

void printmovie (movies_t movie)
{
  cout << movie.title;
  cout << " (" << movie.year << ")\n";
}

Pointers to structures

struct movies_t {
  char title [50];
  int year;
};

movies_t amovie;
movies_t * pmovie;

pmovie = &amovie;

// pointers to structures
#include <iostream.h>
#include <stdlib.h>

struct movies_t {
  char title [50];
  int year;
};


int main ()
{
  char buffer[50];

  movies_t amovie;
  movies_t * pmovie;
  pmovie = & amovie;

  cout << "Enter title: ";
  cin.getline (pmovie->title,50);
  cout << "Enter year: ";
  cin.getline (buffer,50);
  pmovie->year = atoi (buffer);

  cout << "\nYou have entered:\n";
  cout << pmovie->title;
  cout << " (" << pmovie->year << ")\n";

  return 0;
}

The previous code includes a new important, the operator ->. This is a reference operator that is used exclusively with pointers to structures and pointers to classes. It allows us not to have to use parenthesis on each reference to a structure member. In the example we used:

movies->title

(*movies).title

*movies.title

*(movies.title)

Expression	Description	Equivalent
movies.title	Element title of structure movies
movies->title	Element title of structure pointed by movies	(*movies).title
*movies.title	Value pointed by element title of structure movies	*(movies.title)

Nesting structures

struct movies_t {
  char title [50];
  int year;
}

struct friends_t {
  char name [50];
  char email [50];
  movies_t favourite_movie;
  } charlie, maria;

friends_t * pfriends = &charlie;

charlie.name
maria.favourite_movie.title
charlie.favourite_movie.year
pfriends->favourite_movie.year

The concept of structures that has been discussed in this section is the same used in C language, nevertheless, in C++, the structure concept has been extended up to the same functionality of a class with the peculiarity that all of its elements are considered public. But you will have more details about this topic on section 4.1, Classes.

© The C++ Resources Network, 2000-2001 - All rights reserved

Previous: 3-4. Dynamic memory

index

Next: 3-6. User defined data types.