- C++ Programming Basics
- C++ Tutorial
- C++ Environment Setup
- C++ Character Set
- C++ Keywords
- C++ Identifiers
- C++ Constants
- C++ Punctuators
- C++ Program Structure
- C++ Basic Syntax
- C++ Comments
- C++ Basic Programs
- C++ Input Output Operator
- C++ Input Output Stream
- C++ Type & Variable
- C++ Data Types
- C++ Data Type Modifiers
- C++ Variables
- C++ Variable Types
- C++ Variable Scope
- C++ Storage Classes
- C++ Formatting Output
- C++ Operators
- C++ Operators
- C++ Type Conversion
- C++ Numbers
- C++ Assignment Operator
- C++ Shorthand
- C++ Flow of Control
- C++ Statements
- C++ Flow Control
- C++ Decision Making
- C++ if if-else if-else-if switch
- C++ Loops
- C++ for while do-while Loop
- C++ break continue goto
- C++ Standard Library
- C++ Standard Library
- C++ Header Files
- C++ Character String
- C++ Mathematical Functions
- C++ Functions
- C++ Functions
- C++ Function Types
- C++ Function Prototype
- C++ Function Call
- C++ Function Return
- C++ Friend Function
- C++ Scope Rules
- C++ Arrays & Strings
- C++ Arrays
- C++ One Dimensional Arrays
- C++ Two Dimensional Arrays
- C++ Strings
- C++ Data Structure
- C++ Data Structure
- C++ Access Structure Member
- C++ Nested Data Structure
- C++ Structure Array
- C++ Pass Structure to Function
- C++ typedef
- C++ #define
- C++ Programming Pointers
- C++ Pointers
- C++ Memory Map
- C++ Free Store
- C++ Declare Initialize Pointers
- C++ Dynamic Memory Allocation
- C++ Pointers & Arrays
- C++ Pointers & Const
- C++ Pointers & Functions
- C++ Pointers & Structures
- C++ Objects as Function Arguments
- C++ Pointers & Objects
- C++ References
- C++ File Handling
- C++ File Handling
- C++ File Streams
- C++ Data Files
- C++ Opening & Closing Files
- C++ Steps to Process Files
- C++ Change Stream Behaviour
- C++ Sequential I/O Operations
- C++ Detecting EOF
- C++ File Pointers Random Access
- C++ Binary Files Operations
- C++ Error Handling
- C++ Object Oriented
- C++ Object Oriented
- C++ Function Overloading
- C++ Classes & Objects
- C++ Constructors & Destructors
- C++ Inheritance
- C++ Encapsulation
- C++ Polymorphism
- C++ Data Abstraction
- C++ Interfaces
- C++ Programming Advance
- C++ Linked Lists
- C++ Stacks
- C++ Queues
- C++ Date Time
- C++ Preprocessors
- C++ Exception Handling
- C++ Namespaces
- C++ Dynamic Memory
- C++ Multithreading
- C++ Templates
- C++ Signal Handling
- C++ Web Programming
- C++ Programming Examples
- C++ Programming Examples
- C++ Programming Test
- C++ Programming Test
- Give Online Test
- All Test List
C++ Pointers and Structures
C++ allows pointers to structures just as it allows pointers to int or char or float or any other data type. The pointers to structures are known as structure pointers.
Declaration and Use of Structure Pointers in C++
Just like other pointers, the structure pointers are declared by placing asterisk (∗) in front of a structure pointer's name.
It takes the following general form :
struct-name ∗struct-pointer ;
where struct-name is the name of an already defined structure and struct-pointer is the pointer to this structure. For example, to declare dt-ptr as a pointer to already defined structure date, we shall write
date ∗ dt-ptr ;
The declaration of structure type and the structure pointer can be combined in one statement. For example,
struct date { short int dd, mm, yy ; } ; date ∗ dt_ptr ;
is same as
struct date { short int dd, mm, yy ; } ∗ dt_ptr ;
Using structure pointers, the members of structures are accessed using arrow operator ->. To refer to the structure members using -> operator, it is written as
struct-pointer -> structure-member
That is, to access dd and yy with dt_ptr, we shall write
dt_ptr -> yy
and
dt_ptr -> dd
C++ Structure Pointers Example
Let's look at the following program which demonstrates the usage of these pointers :
/* C++ Pointers and Structures. This C++ program * demonstrates about declaration and the use of * Structure Pointers in C++ */ #include<iostream.h> #include<conio.h> void main() { struct date { short int dd, mm, yy; }join_date = {19, 12, 2006}; date *date_ptr; date_ptr = &join_date; cout<<"Printing the structure elements using the structure variable\n"; cout<<"dd = "<<join_date.dd<<", mm = "<<join_date.mm<<", yy = "<<join_date.yy<<"\n"; cout<<"\nPrinting the structure elements using the structure pointer\n"; cout<<"dd = "<<date_ptr->dd<<", mm = "<<date_ptr->mm<<", yy = "<<date_ptr->yy<<"\n"; getch(); }
When the above C++ program is compile and executed, it will produce the following output:

The above program is self-explanatory. Remember that the dot operator ('.') requires a structure variable on its left and the arrow operator ('->') requires a structure pointer on its left. The arrow operator consists of the minus sign followed by greater than sign.
There are the following two primary uses of for structure pointers :
- to generate a call by reference call to a function.
- to create dynamic data structures like linked lists, stacks, queues, trees etc. using C++'s dynamic allocation system.
The structure pointer are very much useful in generating call by reference call to function because when a pointer to a structure is passed to a function, only the address of the structure is passed. This makes way for very fast function calls. A second advantage of it is when a function needs to reference the actual structure argument instead of a copy of them, by passing a pointer, it can modify the contents of the actual elements of the structure used in the call.
Here is another example program given, that you can take a look, for the complete understanding on the structure pointers in C++
/* C++ Pointers and Structures. This C++ program * also demonstrates the structure pointer in C++ */ #include<iostream.h> #include<conio.h> #include<string.h> #include<stdio.h> struct emp { int empno; char empname[20]; float empbasic; float empexperience; }; void display(emp *e); void increase(emp *e); void main() { clrscr(); emp mgr, *eptr; cout<<"Enter employee number: "; cin>>mgr.empno; cout<<"Enter name: "; gets(mgr.empname); cout<<"Enter basic pay: "; cin>>mgr.empbasic; cout<<"Enter experience (in years): "; cin>>mgr.empexperience; eptr = &mgr; cout<<"\nEmployee details before increase()\n"; display(eptr); increase(eptr); cout<<"\nEmployee details after increase()\n"; display(eptr); getch(); } void display(emp *e) { int len=strlen(e->empname); cout<<"Employee number: "<<e->empno; cout<<"\nName: "; cout.write(e->empname, len); cout<<"\tBasic: "<<e->empbasic; cout<<"\tExperience: "<<e->empexperience<<" years\n"; } void increase(emp *e) { if(e->empexperience >= 5) { e->empbasic = e->empbasic + 15000; } }
Here are the two sample runs of the above C++ program. One for the employee having experience less than 5 years and the other having experience more than 5 years.


Self Referencial Structures in C++
A structure having a member element that refer to the structure itself, is known as Self-Referencial Structure.
To understand the self-referencial structures, we shall first talk about a situation. Suppose you are required to write a program that stores and manipulates details of quite-many employees, details like empno, name, basic, and experience etc. Going through this problem, this immediately suggests the use of structures to hold the information. However, how will these structures be stored and manipulated ? For this problem, you may use a fixed-size array of structures. But a fixed-size array has some serious drawbacks. An important one of them is, the size of the array arbitrarily limits the length of the list of employees. What if you realize during program-run that the array should have been of bigger size ? To avoid such a problem, you would certainly go for a dynamic list so that the list can be as large as free memory allows.
A dynamic linear list in C++ is called a linked-list. One major use of linked lists is to create arrays of unknown size in memory.
A linked list requires that each item of information contain a link to the next element in the list. Each data item usually consists of a structure that includes information fields and a link pointer. You will learn about linked list in the later chapter in detail.
A linked list is a structure having an additional pointer as its element that points to a structure of the same type.
That is to declare the above shown structure type, we shall write
struct Employee { int empno ; char name[26] ; float basic ; float experience ; Employee ∗ next ; / pointer to same structure type };
See the structure contains an element that refers to the structure itself. Such a structure is called self-referencial structure.
C++ Dynamic Structures
The new operator can be used to create dynamic structures also i.e., the structures for which the memory is dynamically allocated. To do so, we write in the following form :
struct-pointer = new struct-type ;
where struct-type is the predefined structure type for which the memory is being allocated and struct-pointer is a pointer of struct-type type that stores the address of newly allocated memory. For instance, to allocate memory dynamically for Employee structure defined above, we may give
Employee ∗eptr ; eptr = new Employee ;
A dynamic structure can be released using the deallocation operator delete as shown below :
delete struct-pointer ;
where struct-pointer is the same pointer that was pointing to the dynamically allocated memory. That is, to release memory which is being pointed to by eptr, we shall write
delete eptr ;
« Previous Tutorial Next Tutorial »