Structure Pointers in C Plus Plus

Structure Pointers in C Plus Plus

This tutorial explores structure pointers in C Plus Plus (C++). We examine the syntax required to create and manipulate the pointer. We also discuss implementation details and possible pitfalls.

A simple example in code

We begin with a brief example in code. The following program should compile, link, and execute in any modern C++ compiler, but it has no functionality beyond illustrating concepts relating to pointers to structures. It is a useful starting point for discussion.

#include <iostream>
using namespace std;

struct myStruct {
	int alpha;
	float delta;
	char beta[10];
};
void main()
{
	myStruct m;	// Declare in instance of our structure.
	myStruct *mPtr; // Declare a pointer to an instance of our structure.
}

Analysis of the above code sample

Let us examine the code sample presented above. Lines 4 though 8 define a new data type called myStruct. In line 11 we declare a variable of type myStruct called m. In line 12, however, we declare a pointer to a structure of type myStruct. The difference between lines 11 and 12 is significant. Line 11 allocates enough space to hold an entire structure. Assuming 4 byte integers, 4 byte floats, 1 byte chars, and word-boundary addressing, the size of the variable declared in line 11 is 18 bytes.

The variable in line 12, on the other hand, is quite a bit smaller. Assuming a 32 bit addressing scheme, line 12 allocates a variable called mPtr that is 4 bytes wide. We can use the variables m and mPtr in very similar ways, but every programmer must recognize the difference between them in order to write robust and error-free software.

The variable m is ready to store an entire structure. The variable mPtr is virtually useless until it is initialized to point to a usable memory location. In other words, we cannot reliably dereference the pointer until we know where it points. A quick and dirty solution is to initialize it to point to the variable m. Refer to the modified code that follows:

#include <iostream>
using namespace std;

struct myStruct {
	int alpha;
	float delta;
	char beta[10];
};
void main()
{
	myStruct m;	// Declare in instance of our structure.
	myStruct *mPtr; // Declare a pointer to an instance of our structure.
	mPtr = &m;	// & is read as "address of"
}

Line 13 in the above code serves to initialize the pointer to the address of the variable m. After this initialization we are able to safely dereference mPtr and do useful work with it. In the following code snippet we demonstrate just how to do that.

#include <iostream>
using namespace std;

struct myStruct {
	int alpha;
	float delta;
	char beta[10];
};
void main()
{
	myStruct m;	// Declare in instance of our structure.
	myStruct *mPtr; // Declare a pointer to an instance of our structure.
	mPtr = &m;	// & is read as "address of"
	mPtr->alpha = 42;	// dereference the pointer
	mPtr->delta= 100.42;
}

We see in lines 14 and 15 that the dereference operator is '->' (quotes added for clarity only). This operator is actually 2 keystrokes. We would be in error if we attempted to write to the structure using the traditional dot operator that works with structure variables (such as our m variable):

	mPtr.alpha = 42; // This will not compile

The above line will not compile. A pointer to a struct requires the dereference operator, not the dot operator, in order to refer to members of the structure.

What could go wrong?

We move on to a common problem among C and C++ (C Plus Plus) programmers; the improperly initialized pointer. Consider the following code snippet, which is intentionally polluted with a logic error:

#include <iostream>
using namespace std;

struct myStruct {
	int alpha;
	float delta;
	char beta[10];
};
void main()
{
	myStruct m;	// Declare in instance of our structure.
	myStruct *mPtr; // Declare a pointer to an instance of our structure.
	mPtr->alpha = 42; // This is big trouble.
}

The above code will compile, but it has a nasty logic error. The pointer variable, mPtr, is dereferenced before it is properly initialized. We know that C/C++ does not initialize a local variable to a known state at the time it is declared. The pointer mPtr is a local variable due the fact that it is declared inside the code block that comprises the main() function. Local variables simply end up containing whatever was in memory at the time that space is allocated to contain them. Typically a local variable is allocated space on the program stack, but regardless of where the variable resides, we must be sure to initialize it to a known state before we attempt to dereference it.

Our code may crash and burn in line 13, when the address of alpha is computed and 42 is written to that address. We cannot predict the precise behavior of the program because we don't know what the value of mPtr will be when line 13 executes. If mPtr points to a location in memory that is expendable, the program may appear to run properly. In fact, it may appear to run properly for years. On the other hand, if mPtr points to a memory location that our program does not have permission to write to, we may see a protection fault thrown by line 13. A third possibility may be that Line 13 overwrites a memory location that our program has permission to access, but that location contains data we need elsewhere in the code; we may be clobbering our own data.

These types of uninitialized pointer problems can be challenging to debug. The same executable program may execute differently on different computers.

Conclusion

We have demonstrated basic structure pointer declaration and manipulation in C Plus Plus (C++). We have also demonstrated a common error made when manipulating these pointers.

More by this Author


Comments 2 comments

OpinionDuck profile image

OpinionDuck 6 years ago

nicomp

nice hub on the simplest but tricky coding.

allocation versus initialization.

nice use of the code snippets.


nicomp profile image

nicomp 6 years ago from Ohio, USA Author

@OpinionDuck: Thanks, Duck! I appreciate your comments.

    Sign in or sign up and post using a HubPages Network account.

    0 of 8192 characters used
    Post Comment

    No HTML is allowed in comments, but URLs will be hyperlinked. Comments are not for promoting your articles or other sites.


    Click to Rate This Article
    working