CodeProject: A Beginner's Guide to Pointers. Free source code and programming help

Report Article

Discuss

Send to a friend

327 votes for this Article.

Popularity: 11.14 Rating: 4.43 out of 5

Download source files - 3.1 KB

What Are Pointers?

Pointers are basically the same as any other variable. However, what is different about them is that instead of containing actual data, they contain a pointer to the memory location where information can be found. This is a very important concept. Many programs and ideas rely on pointers as the basis of their design, linked lists for example.

Getting Started

How do I define a pointer? Well, the same as any other variable, except you add an asterisk before its name. So, for example, the following code creates two pointers, both of which point to an integer:

int* pNumberOne;
int* pNumberTwo;

Notice the "p" prefix in front of the two variable names? This is a convention used to indicate that the variable is a pointer. Now, let's make these pointers actually point to something:

pNumberOne = &some_number;
pNumberTwo = &some_other_number;

The & (ampersand) sign should be read as "the address of" and causes the address in memory of a variable to be returned, instead of the variable itself. So, in this example, pNumberOne is set to equal the address of some_number, so pNumberOne now points to some_number.

Now if we want to refer to the address of some_number, we can use pNumberOne. If we want to refer to the value of some_number from pNumberOne, we would have to say *pNumberOne. The * dereferences the pointer and should be read as "the memory location pointed to by," unless in a declaration, as in the line int *pNumber.

What We've Learned So Far: An Example

Phew! That's a lot to take in. I'd recommend that if you don't understand any of those concepts, to give it another read through. Pointers are a complex subject and it can take a while to master them. Here is an example that demonstrates the ideas discussed above. It is written in C, without the C++ extensions.

#include <stdio.h>


void main()
{
    // declare the variables:

    int nNumber;
    int *pPointer;

    // now, give a value to them:

    nNumber = 15;
    pPointer = &nNumber;

    // print out the value of nNumber:

    printf("nNumber is equal to : %d\n", nNumber);

    // now, alter nNumber through pPointer:

    *pPointer = 25;

    // prove that nNumber has changed as a result of the above by 

    // printing its value again:

    printf("nNumber is equal to : %d\n", nNumber);
}

Read through and compile the above code sample. Make sure you understand why it works. Then, when you are ready, read on!

A Trap!

See if you can spot the fault in the program below:

#include <stdio.h>


int *pPointer;

void SomeFunction();
{
    int nNumber;
    nNumber = 25;    

    // make pPointer point to nNumber:

    pPointer = &nNumber;
}

void main()
{
    SomeFunction(); // make pPointer point to something


    // why does this fail?

    printf("Value of *pPointer: %d\n", *pPointer);
}

This program firstly calls the SomeFunction function, which creates a variable called nNumber and then makes the pPointer point to it. Then, however, is where the problem is. When the function leaves, nNumber is deleted because it is a local variable. Local variables are always deleted when execution leaves the block they were defined in. This means that when SomeFunction returns to main(), the variable is deleted. So pPointer is pointing at where the variable used to be, which no longer belongs to this program. If you do not understand this, it may be wise to read back over on local and global variables, and on scope. This concept is also important.

So, how can the problem be solved? The answer is by using a technique known as dynamic allocation. Please be aware that this is different between C and C++. Since most developers are now using C++, this is the dialect that the code below is using.

Dynamic Allocation

Dynamic allocation is perhaps the key to pointers. It is used to allocate memory without having to define variables and then make pointers point to them. Although the concept may appear confusing, it is really simple. The following code demonstrates how to allocate memory for an integer:

int *pNumber;
pNumber = new int;

The first line declares the pointer, pNumber. The second line then allocates memory for an integer and then makes pNumber point to this new memory. Here is another example, this time using a double:

double *pDouble;
pDouble = new double;

The formula is the same every time, so you can't really fail with this bit. What is different about dynamic allocation, however, is that the memory you allocate is not deleted when the function returns, or when execution leaves the current block. So, if we rewrite the above example using dynamic allocation, we can see that it works fine now:

#include <stdio.h>


int *pPointer;

void SomeFunction()
{
    // make pPointer point to a new integer

    pPointer = new int;
    *pPointer = 25;
}

void main()
{
    SomeFunction(); // make pPointer point to something

    printf("Value of *pPointer: %d\n", *pPointer);
}

Read through and compile the above code sample. Make sure you understand why it works. When SomeFunction is called, it allocates some memory and makes pPointer point to it. This time, when the function returns, the new memory is left intact, so pPointer still points to something useful. That's it for dynamic allocation! Make sure you understand this, and then read on to learn about the fly in the ointment, and why there is still a serious error in the code above.

Memory Comes, Memory Goes

There's always a complication and this one could become quite serious, although it's very easy to remedy. The problem is that although the memory that you allocate using dynamic allocation is conveniently left intact, it actually never gets deleted automatically. That is, the memory will stay allocated until you tell the computer that you've finished with it. The upshot of this is that if you don't tell the computer that you've finished with the memory, it will be wasting space that other applications or other parts of your application could be using. This eventually will lead to a system crash through all the memory being used up, so it's pretty important. Freeing the memory when you've finished with it is very simple:

delete pPointer;

That's all there is to it. You have to be careful, however, that you pass a valid pointer, i.e. that is a pointer that actually points to some memory you've allocated and not just any old rubbish. Trying to delete memory that's already been freed is dangerous and can lead to your program crashing. So here is the example again, updated this time so it doesn't waste any memory:

#include <stdio.h>


int *pPointer;

void SomeFunction()
{
// make pPointer point to a new integer

    pPointer = new int;
    *pPointer = 25;
}

void main()
{
    SomeFunction(); // make pPointer point to something

    printf("Value of *pPointer: %d\n", *pPointer);

    delete pPointer;
}

One line difference is all it took, but this line is essential. If you don't delete the memory, you get what is known as a "memory leak," where memory is gradually leaking away and can't be reused unless the application is closed.

Passing Pointers to Functions

The ability to pass pointers to functions is very useful, but very easy to master. If we were to make a program that takes a number and adds five to it, we might write something like the following:

#include <stdio.h>


void AddFive(int Number)
{
    Number = Number + 5;
}

void main()
{
    int nMyNumber = 18;
    
    printf("My original number is %d\n", nMyNumber);
    AddFive(nMyNumber);
    printf("My new number is %d\n", nMyNumber);
}

However, the problem with this is that the Number referred to in AddFive is a copy of the variable nMyNumber passed to the function, not the variable itself. Therefore, the line Number = Number + 5 adds five to the copy of the variable, leaving the original variable in main() unaffected. Try running the program to prove this.

To get around this problem, we can pass a pointer to where the number is kept in memory to the function, but we'll have to alter the function so that it expects a pointer to a number, not a number. To do this, we change void AddFive(int Number) to void AddFive(int* Number), adding the asterisk. Here is the program again, with the changes made. Notice that we have to make sure we pass the address of nMyNumber instead of the number itself? This is done by adding the & sign, which (as you will recall) is read as "the address of."

#include <stdio.h>

void AddFive(int* Number)
{
    *Number = *Number + 5;
}

void main()
{
    int nMyNumber = 18;
    
    printf("My original number is %d\n", nMyNumber);
    AddFive(&nMyNumber);
    printf("My new number is %d\n", nMyNumber);
}

Try coming up with an example of your own to demonstrate this. Notice the importance of the * before Number in the AddFive function? This is needed to tell the compiler that we want to add five to the number pointed to by the variable Number, rather than add five to the pointer itself. The final thing to note about functions is that you can return pointers from them as well, like this:

int * MyFunction();

In this example, MyFunction returns a pointer to an integer.

Pointers to Classes

There are a couple of other caveats with pointers, one of which is structures or classes. You can define a class as follows:

class MyClass
{
public:
    int m_Number;
    char m_Character;
};

Then you can define a variable of type MyClass as follows:

MyClass thing;

You should already know this. If not, try reading up on this area. To define a pointer to MyClass, you would use:

MyClass *thing;

...as you would expect. Then you would allocate some memory and make this pointer point to the memory:

thing = new MyClass;

This is where the problem comes in: how then would you use this pointer? Well, normally you would write'thing.m_Number, but you can't with a pointer because thing is not a MyClass, but a pointer to it. So, thing itself does not contain a variable called m_Number; it is the structure that it points to that contains m_Number. Therefore we must use a different convention. This is to replace the . (dot) with a -> (dash followed by a greater than sign). An example showing this is below:

class MyClass
{
public:
    int m_Number;
    char m_Character;
};

void main()
{
    MyClass *pPointer;
    pPointer = new MyClass;

    pPointer->m_Number = 10;
    pPointer->m_Character = 's';

    delete pPointer;
}

Pointers to Arrays

You can also make pointers that point to arrays. This is done as follows:

int *pArray;
pArray = new int[6];

This will create a pointer, pArray, and make it point to an array of six elements. The other method, not using dynamic allocation, is as follows:

int *pArray;
int MyArray[6];
pArray = &MyArray[0];

Note that, instead of writing &MyArray[0], you can simply write MyArray. This, of course, only applies to arrays and is a result of how they implemented in the C/C++ language. A common pitfall is to write pArray = &MyArray;, but this is incorrect. If you write this, you will end up with a pointer to a pointer to an array (no typo), which is certainly not what you want.

Using Pointers to Arrays

Once you have a pointer to an array, how do you use it? Well, let's say you have a pointer to an array of ints. The pointer will initially point to the first value in the array, as the following example shows:

#include <stdio.h>


void main()
{
    int Array[3];
    Array[0] = 10;
    Array[1] = 20;
    Array[2] = 30;

    int *pArray;
    pArray = &Array[0];

    printf("pArray points to the value %d\n", *pArray);
}

To make the pointer move to the next value in the array, we can say pArray++. We can also, as some of you probably guessed by now, say pArray + 2, which would move the array pointer on by two elements. The thing to be careful of is that you know the what the upper bound of the array is (3 in this example), because the compiler cannot check that you have not gone past the end of array when you are using pointers. You could easily end up crashing the system that way. Here is the example again, this time showing the three values that we set:

#include <stdio.h>


void main()
{
    int Array[3];
    Array[0] = 10;
    Array[1] = 20;
    Array[2] = 30;

    int *pArray;
    pArray = &Array[0];

    printf("pArray points to the value %d\n", *pArray);
    pArray++;
    printf("pArray points to the value %d\n", *pArray);
    pArray++;
    printf("pArray points to the value %d\n", *pArray);
}

You can also subtract values, so pArray - 2 is 2 elements from where pArray is currently pointing. Make sure, however, that you add or subtract to the pointer and not to its value. This kind of manipulation using pointers and arrays is most useful when used in loops, such as the for or while loops.

Note also that if you have a pointer to a value, e.g. int* pNumberSet, you can treat it as an array. For example, pNumberSet[0] is equivalent to *pNumberSet; similarly, pNumberSet[1] is equivalent to *(pNumberSet + 1).

One final word of warning for arrays is that if you allocate memory for an array using new, as in the following example:

int *pArray;
pArray = new int[6];

...it must be deleted using the following:

delete[] pArray;

Notice the [] after delete. This tells the compiler that it is deleting a whole array and not just a single item. You must use this method whenever arrays are involved; otherwise, you will end up with a memory leak.

Last Words

One final note: you must not delete memory that you did not allocate using new, as in the following example:

void main()
{
    int number;
    int *pNumber = number;
    
    delete pNumber; // wrong - *pNumber wasn't allocated using new.

}

Common Questions and FAQ

Q: Why do I get "symbol undefined" errors on new and delete?

A: This is most likely caused by your source file being interpreted by the compiler as being a plain C file. The new and delete operators are a new feature of C++. This is usually remedied by ensuring that you are using a *.cpp extension on your source code files.

Q: What's the difference between new and malloc?

A: new is a keyword only present in C++ and is now the standard way (other than using Windows' memory allocation routines) to allocate memory. You should never use malloc within a C C++ application unless absolutely necessary. Because malloc is not designed for the object-oriented features of C++, using it to allocate memory for classes will prevent the constructor of the class being called, as just one example of the problems that can arise. As a result of the problems that arise from the use of malloc and free, and because they are now for all intents and purposes obsolete, they are not discussed in any detail in this article. I would discourage their use wherever possible.

Q: Can I use free and delete together?

A: You should free memory with the equivalent routine to that used to allocated it. For instance, use free only on memory allocated with malloc, delete only on memory allocated with new and so on.

References

References are, to a certain degree, out of the scope of this article. However, since I've been asked many times by people reading this about them, I will discuss them briefly. They are very much related to pointers in that, in many cases, they can be used as a simpler alternative. If you recall from above, I mentioned that the ampersand (&) is read as "the address of" unless in a declaration. In the case of its presence in a declaration such as that shown below, it should be read as "a reference to."

int& Number = myOtherNumber;
Number = 25;

The reference is like a pointer to myOtherNumber, except that it is automatically dereferenced. So, it behaves just as it were the actual value type rather than a pointer type. The equivalent code to this, using pointers, is shown below:

int* pNumber = &myOtherNumber;
*pNumber = 25;

The other difference between pointers and references is that you cannot "reseat" a reference. That is to say that you cannot change what it is pointing to after its declaration. For instance, the following code would output "20."

int myFirstNumber = 25;
int mySecondNumber = 20;
int &myReference = myFirstNumber;

myReference = mySecondNumber;

printf("%d", myFristNumber);

When in a class, the value of the reference must be set by the constructor in the following way:

CMyClass::CMyClass(int &variable) : m_MyReferenceInCMyClass(variable)
{
    // constructor code here

}

Summary

This topic is very hard to master initially, so it is worth looking over at least twice: most people do not understand it immediately. Here are the main points again:

Pointers are variables that point to an area in memory. You define a pointer by adding an asterisk (*) in front of the variable name (i.e. int *number).
You can get the address of any variable by adding an ampersand (&) in front of it, i.e. pNumber = &my_number.
The asterisk, unless in a declaration (such as int *number), should be read as "the memory location pointed to by."
The ampersand, unless in a declaration (such as int &number), should be read as "the address of."
You can allocate memory using the new keyword.
Pointers MUST be of the same type as the variables you want them to point to; so, int *number will not point to a MyClass.
You can pass pointers to functions.
You must delete memory that you have allocated by using the delete keyword.
You can get a pointer to an array that already exists by using &array[0];.
You must delete an array that is dynamically allocated using delete[], not just delete.

This is not an absolutely complete guide to pointers. There are a few other things that I could have covered in more detail, such as pointers to pointers, and also things that I chose not to cover at all, such as function pointers, which I believe are too complex for a beginner's article. There are also things which are used rarely enough that a beginner would be better off not being flummoxed by these unwieldy details.

That's it! Try running some of the programs presented here and come up with some examples of your own.

Updates

29 June 2002 - Article first posted to The Code Project
10 July 2002 - FAQ added, some minor changes throughout article to improve clarity, updating of an incorrectly placed source code snippet, addition of section on references

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Andrew Peace

Andrew is currently a student at the University of Cambridge, working towards a degree in Computer Science. The word 'working' is used here in a vague sense, with the hope that the reader will realise that the same sentence contained the word 'student'.

Aside from computing he has a strong interest in music, and enjoys the outdoors, particularly when the weather permits going out in them... To Andrew, cycling is fun, sailing is more fun, and the odd camping trip and walk is certainly what the doctor ordered.

In terms of programming experience, he first started writing programs for the Commodore Amiga using BASIC, after which he learned the joys of C and has never looked back. Since, he has added C++ and C# to his repotoire, along with a bunch of other crazy languages like ML that they like to teach in college.

Location:

United Kingdom

Other popular C / C++ Language articles:

Member Function Pointers and the Fastest Possible C++ Delegates
A comprehensive tutorial on member function pointers, and an implementation of delegates that generates only two ASM opcodes!
How a C++ compiler implements exception handling
An indepth discussion of how VC++ implements exception handling. Source code includes exception handling library for VC++.
What's up with BeginInvoke?
Why and when to use Control.BeginInvoke()?
XML class for processing and building simple XML documents
Link CMarkup into your VC++ app and avoid complex XML tools and dependencies
How to write a loading circle animation in .NET?
A new kind of progress bar for .NET 2.0.

Article Top

You must Sign In to use this message board.

Msgs 1 to 25 of 272 (Total in Forum: 272) (Refresh)

FirstPrevNext

Subject

Author

Date

Nice glance at pointers!

dimension_software

12:52 6 Jan '08

This is a good introductory article to pointers for beginners. Excellent Work! Ahmed El-Deeb
Sign In·View Thread·PermaLink	1.00/5 (1 vote)

trap in pointers

Shajean

21:11 19 Nov '07

u have shown that when the local variable is deleted the assigned pointer becomes a dangling pointer but this issue exists even if we use dynamic allocation. During dynamic allocation we allocate a memory for the pointer and after that if a local variable is assigned to pointer and then the local variable gets deleted then again our pointer is a dangling pointer. Please correct me if I'm wrong..
Sign In·View Thread·PermaLink

Re: trap in pointers

Geoff Bolton

16:51 20 Jan '08

Shajean wrote:
During dynamic allocation we allocate a memory for the pointer and after that if a local variable is assigned to pointer and then the local variable gets deleted then again our pointer is a dangling pointer. Please correct me if I'm wrong.

I think what you're talking about is the reverse situation, where you allocate a block of memory and then "forget" its address. You would call that a memory leak, rather than a dangling pointer, because you no longer HAVE a pointer to your block. Don't think of the memory block itself as a "pointer"...

void my_mem_leak() {
    char* block = new char[10];
}

When the function finishes, 'block' goes out of scope, thus losing the address for the memory you requested. Now your program has no way of knowing that it owns that block. Thus it is 'leaked' and will remain unusable until the operating system releases it (when your program exits).

It's actually ok to let your pointers go out of scope as long as you pass the address on. For example, many functions allocate memory and return the pointer as the result. Internally, your pointer to the block goes out of scope, but its value is returned to the caller just before then! Consider a hypothetical implementation of strdup():

char* my_strdup( const char* str ) {
   // Allocate space to hold the string, including null-terminator.
   int len = strlen(str) + 1;
   char* newstr = new char[len];
   if( newstr == NULL ) return NULL;

   // Copy all characters, including the null-terminator.
   for( int i = 0; i < len; ++i )
      newstr[i] = str[i];

   // Return the address of the new string.
   return newstr;
}

int main( int argc, char* argv[] ) {
   char* s = my_strdup( "Hello, world!" );
   printf( "%s\n", s );
   delete s;

   return 0;
}

Even though 'newstr' goes out of scope, its value is returned to the caller via 'return'. The caller is now responsible for deleting the memory when no longer required. Remember a pointer is just a number. There's nothing else special about it.

-g-

Point to memory address?

soscpd

5:17 14 Nov '07

I ike to build a memory leak detector/cleaner code. I can, already, know the exactly phisical memory address of objects, but i cant point or delete them. How can i point to one exactly memory address (not expecting a good behavior from the application)? (I know the memory location is protected by the OS and the memory address is relative to the process, so, Im loading a dll with the application to have a code injection there. Ots a hack, but... i can maybe put the main daemon in another host using rpc... endless options). The general idea is to have one daemon running in the machine doing collect-garbage and leak detection in every developed application (lots of 3d graphic applications).

Thanks in advance. Its a nice article.

Regards
Rafael

Re: Point to memory address?

BPC

10:10 4 Dec '07

This application allows you to attach to a process and then detect memory allocations and deallocations. Probably a good place to start. http://www.codeproject.com/KB/cpp/MemoryHooks.aspx[^]
Sign In·View Thread·PermaLink

Re: Point to memory address?

soscpd

19:28 10 Jan '08

Hey, thanks Regards Rafael
Sign In·View Thread·PermaLink

Impressive

John R. Shaw

19:54 13 Nov '07

A very impressive article on pointers for beginners, it sounds like you may have some books to write in your future. I would like to see you write a follow up article called some thing like “A Beginner’s Guide to Function Pointers” or some such thing, as you have a knack for explaining the basics.

The new one could cover such things as pointers to pointer and what they are good for, along with the explanation of function pointers. Like how and why the C qsort() takes the parameters that it does.

Thanks, I think I will be pointing some beginners in this direction, in the future.

INTP
"Program testing can be used to show the presence of bugs, but never to show their absence."Edsger Dijkstra

feedback

deostroll

3:56 10 Sep '07

please add something on function pointers.
Sign In·View Thread·PermaLink

Re: feedback

BPC

12:14 13 Feb '08

Have a look at this link for an in depth discussion of function pointers http://www.codeproject.com/KB/cpp/FastDelegate.aspx[^]
Sign In·View Thread·PermaLink

C++ Pointers Book

Vasudevan Deepak Kumar

18:56 22 Feb '07

I came across a nice book on C++ Pointers by Yashwant Kanetkar. http://www.mouthshut.com/review/Let_us_''C''_-_Yashwant_Kanetkar-56919-1.html[^] Vasudevan Deepak Kumar Personal Homepage Tech Gossips
Sign In·View Thread·PermaLink	5.00/5 (1 vote)

You have to check you Guide again!!

MrExclusive

8:57 19 Jan '07

Hi..
In the Trap section, the code that you had wrote is totally wrong. you are just now confusing people with this code. Didn't you try it before putting it? because I have tried this code and it prints the number that it's pointed by pPointer.
There are some mistakes too man.
you have to check'em.
Anyway, it's real good for beginners but it needs some review in some parts.
Thanks a lot.
MrExclusive.
Note:- Electrical Engineer.

1.00/5 (3 votes)

Re: You have to check you Guide again!!

Nishant Sivakumar

9:10 19 Jan '07

MrExclusive wrote:
Hi..
In the Trap section, the code that you had wrote is totally wrong. you are just now confusing people with this code. Didn't you try it before putting it? because I have tried this code and it prints the number that it's pointed by pPointer.
There are some mistakes too man.
you have to check'em.
Anyway, it's real good for beginners but it needs some review in some parts.
Thanks a lot.
MrExclusive.
Note:- Electrical Engineer.

Regards,
Nish

Nish’s thoughts on MFC, C++/CLI and .NET (my blog)
Currently working on C++/CLI in Action for Manning Publications. (*Sample chapter available online*)

Re: You have to check you Guide again!!

Andrew Peace

14:11 19 Jan '07

Hi,

Thanks for your feedback. It is co-incidence if the number printed is correct - the memory has been released back to the heap and so is not guaranteed not to have been overwritten. This has been discussed in other threads in this article. The example given is a very simple instance of the problem that I'm trying to describe to make it clear to the reader - real life examples can be much more compelx - but the principle is definitely correct (that pPointer is pointing to an invalid location when it is dereferenced in main()).

What are the other problems that you have with the main() function?

Thanks,
Andrew.

--
Andrew.

Re: You have to check you Guide again!!

BabuZaleela

2:07 10 Apr '07

You just add any printf statement just after the SomeFunction()in the main() and check..
Sign In·View Thread·PermaLink

Re: You have to check you Guide again!!

BPC

18:22 7 May '07

MrExclusive wrote:
In the Trap section, the code that you had wrote is totally wrong. you are just now confusing people with this code. Didn't you try it before putting it? because I have tried this code and it prints the number that it's pointed by pPointer.

Actually Andrew is correct. When memory is allocated for nNumber it is allocated on the stack. The OS adds an entry to its allocation table and makes nNumber the owner of the address. The entry in the allocation table effectively keeps the OS from allocating the memory for nNumber to another value. In other words, it blocks it off.

The address of nNumber can be assigned to a pointer, but the ownership of the memory is not transferred so nNumber retains ownership. Now, this means that when nNumber goes out of scope the entry in the OS allocation table is removed and the memory is released. This operation does not invalidate the pointer and it does not erase the contents of the memory.

Since the pointer can still point to the same memory address, you may be able to print the contents of the memory and receive the correct results, but it's just a fluke and could change if it's reallocated.

"General Pointer to Classes"

Tran Duy Hung

2:33 17 Nov '06

Hi,
Please help me out of the following problem:
Suppose I have two classes derived from same base B


class A : public B {
    int m_a;
    int p_X( void) {
    //Activities of A object
    }
}
class C : public B {
    int m_b;
    int p_X( void) {
    //Activities of C object
    }
}

Now I want a general pointer (say pX) to do:


int main (void) {
   ??? *pX;
   if (something == TRUE) {
      pX = new A();
   } else {
      pX = new C();
   }
   return (pX->p_X());
}

How can I do?

Thank you,

TDH

Re: "General Pointer to Classes" [modified]

aldasp

2:14 27 Nov '06

Base class is allowed:

B *pX;

But You must have define attract class B as shown here:

class B
{
protected:
// abstract method of abstract class
virtual int p_X( void) = 0;
};

class A : public B {
int m_a;

public:
virtual int p_X( void) {
//Activities of A object
}
};

class C : public B {
int m_b;

public:
virtual int p_X( void) {
//Activities of C object
}
};

---
Aldas

-- modified at 3:29 Tuesday 28th November, 2006

Re: "General Pointer to Classes"

Tran Duy Hung

4:39 29 Nov '06

Thank you very much. As your suggestion, for all public methods in A class (and also in C), all of them should be abstract in B. Am I corect? Can I have a D class that extends from both A and C? i.e. Can I specify: `Class B {//abstract }; Class A : public B { }; Class C : public B { }; Class D : public A : public C { };`
Sign In·View Thread·PermaLink

Re: &amp;quot;General Pointer to Classes&amp;quot;

aldasp

13:58 29 Nov '06

Abstract method means can be only virtual,

You MUST implement virtual method
with same name inside base superclass (A or C in Your case).
(must be virtual in base class)

But it is allowed using of virtual NOT abstract method in base class

For example You can implement default basic behaviuor
inside B class virtual method:

class B {// not abstract
public:
virtual const char *getClassName(void)
{
return "base A";
}
};

class A : public virtual B {
public:
virtual const char *getClassName(void)
{
return "subclass A";
}
};

class C : public virtual B {
};

class D : public A , public C {
};

In example above

//B class: default base class behaviour
B *p1 = new B();
cout << p1->getClassName() << '\n'; // "base B"

// C class: default base class behaviour not overwriten inside C!
C *p2 = new C();
cout << p2->getClassName() << '\n'; // "base B"

// A class: default base class behaviour overwriten inside A!
A *p3 = new A();
cout << p3->getClassName() << '\n'; // "subclass A"

// D class: class D behaviour inherited from A!
D *p4 = new D();
cout << p4->getClassName() << '\n'; // "subclass A"

Please note, class B declared as "public virtual"
inside C and A definitions.

This protect B from duplication inside D

---
Aldas

Re: "General Pointer to Classes"

David Nash

17:59 28 Dec '06

This programming technique is called polymorphism. The are many articles describing how to do this on the web. Here's one: http://www.cplusplus.com/doc/tutorial/polymorphism.html regards, David http://users.bigpond.net.au/programming
Sign In·View Thread·PermaLink

Re: "General Pointer to Classes"

Tran Duy Hung

0:05 30 Dec '06

Thank you. Having read your suggestion paper. It is a "merged" polymorphism. Can we do other way, says "split" polymorphism, like: class D public A, public B { //something } but both A and B have same base class E: class A public E class B public E Then it comes, my problem !
Sign In·View Thread·PermaLink

Re: "General Pointer to Classes"

David Nash

21:42 8 Jan '07

When you have a class inherrited from two other classes as you have here, that's called multiple inheritance. Multiple inheritance is complex, and is generally considered a topic for expert programmers (and best avoided by everyone else).

I'm afraid I don't know enough about multiple inheritanc