0

I am trying to learn C++ on my own using the "Teach Yourself C++ in 24 hours" by Jesse Liberty. I wrote this short program to figure out pointers in C++.

#include <iostream>

void hMany(int count); // hMany function prototype


void hMany(int count){
    
    do {
        std::cout << "Hello...\n";
        count--;
        
        }  while (count >0 );
        
};


int main (int argc, const char * argv[]) {
    

    int counter;
    int * pCounter = &counter;
    
    std::cout << "How many hellos? ";
    std::cin >> counter;
    
    hMany(*pCounter);
    
    std::cout << "counter is: " << counter << std::endl;
    std::cout << "*pCounter is: " << *pCounter << std::endl;
    
    return 0;
}

The resulting output is:

How many hellos? 2
Hello...
Hello...
counter is: 2
*pCounter is: 2

What is the benefit of passing the pointers (*pCounter) vs the argument (counter)?

Any help would be greatly appreciated. Luis

Update:

Ok. The program is working and I now fully understand the C++ pointers. Thank you all for your responses. After trying Chowlett's code I was getting 2 warnings (not errors). One was ! No previous prototype for function hMany and *pCount-- ! Expression result unused. I was able to correct the prototype on my own but I couldn't figure out the *pCount-- warning.

I asked my friend Tony for help and here is his answer.

The parentheses make things happen in the correct order.

(*pCount)--

says to follow the pointer to the integer it points to, and then decrement the integer, which is what you want to do.

*pCount--

ends up doing the wrong thing, the compiler treats it as

*(pCount—)

which says to decrement the pointer first, leaving it pointing to the “integer” before the one you want to change (there is no such thing since you only have one integer you called this function with), then follow this decremented pointer and do nothing with the integer at that memory location. This is why the compiler complained that the expression result was unused. The compiler was correct. This code decrements the pointer incorrectly, fetches the wrong integer, and doesn’t store that wrong integer anywhere.

Here's the correct code for those new to C++ who might be interested.

include

void hMany(int *pCount); // hMany function prototype

void hMany(int *pCount){ // *pCount receiving the address of count

do {
    std::cout << "Hello...\n";
   
    
    // The parentheses make things happen in the correct order.
    // says to follow the pointer to the integer it points to, 
    // and then decrement the integer.
    
          (*pCount)--; 
    
}  while (*pCount >0 );

}

int main (int argc, const char * argv[]) {

int counter;
int * pCounter = &counter;

std::cout << "How many hellos? ";
std::cin >> counter;

hMany(pCounter); // passing the address of counter

std::cout << "counter is: " << counter << std::endl;
std::cout << "*pCounter is: " << *pCounter << std::endl;

return 0;

}

Community
  • 1
  • 1
robles1999
  • 1
  • 1
  • 1
    _Pointers_ not _Points_. – masoud Oct 02 '13 at 13:38
  • 10
    Please get a [*good* book](http://stackoverflow.com/q/388242/1171191). `C++` is not a language to learn "in 24 hours". You will just learn horrible practices that will be hard to unlearn and will give you a bad impression of the language. – BoBTFish Oct 02 '13 at 13:40
  • I think the answers below are missing something. In the code above no pointers are being passed to the function. – john Oct 02 '13 at 13:46
  • @john: Because the questioner thinks passing `*pCounter` to the function, means passing the pointer... He has written : _"passing the pointers (*pCounter)"_ – masoud Oct 02 '13 at 13:48
  • @MM. Yes but none of the answers (except now Chowlett's) address this. – john Oct 02 '13 at 13:49
  • Obligatory Norvig reference ... you cannot learn programming in 21 days, let alone 24hrs: http://norvig.com/21-days.html – Fabio Fracassi Oct 02 '13 at 14:35
  • Thank you all for your responses. This is my second attempt at trying to learn C++ on my own. I don't like the fact, that so far with this book, almost on every chapter, I've had to stop to get help with the concept being introduced. I have a friend who is an incredible programmer and has been very kind at helping me understand and moving along. If anyone knows of a good newbie book to pick up please let me know. – robles1999 Oct 03 '13 at 00:04

5 Answers5

2
int counter;
int * pCounter = &counter;

...

hMany(*pCounter); // Pass by value

hMany(counter);   // Pass by value

What is the benefit of passing the point (*pCounter) vs the argument (counter)?

In this case nothing, it's just an educational example. It shows you can dereference a pointer and get its value by * .

In addition, both cases are passing by value.

In practice you should avoid using pointers by default, unless you have a good reason.

masoud
  • 55,379
  • 16
  • 141
  • 208
2

There is no difference between using *pCounter and counter. In both cases, you are passing the value of the variable counter. However, if you actually pass the pointer itself, you get different behaviour.

Consider the slightly different program:

#include <iostream>

void hMany(int* pCount); // hMany function prototype


void hMany(int* pCount){

    do {
        std::cout << "Hello...\n";
        --*pCount;

        }  while (*pCount >0 );

}


int main (int argc, const char * argv[]) {


    int counter;
    int * pCounter = &counter;

    std::cout << "How many hellos? ";
    std::cin >> counter;

    hMany(pCounter);

    std::cout << "counter is: " << counter << std::endl;
    std::cout << "*pCounter is: " << *pCounter << std::endl;

    return 0;
}

In this case, your output will be:

How many hellos? 2
Hello...
Hello...
counter is: 0
*pCounter is: 0

By passing in the pointer to counter (literally, the address in memory of counter), you allow the function to change counter through its memory location.

Chowlett
  • 45,935
  • 20
  • 116
  • 150
  • 1
    Note, one would almost always prefer references for this purpose. – cHao Oct 02 '13 at 13:53
  • Thanks for the help everyone has provided. It has cleared a lot of my confusion with pointers. The value was being passed rather than the address. I now understand * whatEver gets the value and whatEver is the address where the value is stored. However, I copied your code and pasted it on Xcode 4.2, but I didn't experience the same result as you. I had an error on void hMany(int * pCount) ! No previous prototype for function hMany. I changed it to void hMany(int * pCount); and the error went away. I still have and error on *pCount--; ! expression result unused. Any ideas? – robles1999 Oct 02 '13 at 23:48
  • Ah, apologies, I forgot to update the prototype. I'll edit the answer. As for the other compiler complaint, that sounds like a warning rather than an error. `*pCount--` returns the previous value as well as decrementing, and the compiler is pointing out you haven't used it. Does it really refuse to compile? (In any case, `--*pCounter` is probably better, so I'll change the code to that as well.) – Chowlett Oct 03 '13 at 07:55
  • No need to apologize your answer helped me understand pointers better. Thank you. – robles1999 Oct 03 '13 at 12:00
0

What is the benefit of passing the point (*pCounter) vs the argument (counter)?

There's no "benefit" , this is how you are supposed to pass the value pointed by the pointer pCounter.

hMany(*pCounter) -> dereferences pCounter to get value

P0W
  • 46,614
  • 9
  • 72
  • 119
0

The difference is the scope of the variable.

If you pass the variable it is copied to the stack in the local scope of the function. Changing the value is than done in local copy for the function called, if this is the case 1st your using space if the large variable is passed, 2nd you need to return the value from your function (as the stack will be destroyed once you go back)

You can think of it like this:

stack:

current function stack:

[    ]
[    ]
[    ]
[    ]

when you call another 1 element is added 

[    ]
[    ]
[    ]
[    ]
[newel]

when you leave the function it is deleted so its like this again

[    ]
[    ]
[    ]
[    ]

newelement value cant be trusted no more.

But if this is the copy of the pointer, you change not the pointer copy value but the value of the place it points too so the stack will be like this

[    ]
[ actual_value]
[    ]
[ pointer_to_value]

than you call the function

[    ]
[ actual_value]
[    ]
[ pointer_to_value]
[ pointer_to_value_copy]

which will change the actual_value on the stack and quit deleting copy of pointer_to_value

[    ]
[ actual_value**changed]
[    ]
[ pointer_to_value]
cerkiewny
  • 2,761
  • 18
  • 36
0

Pointer actually contains memory address with type information of the value that the memory address represents. It may be used to pass the entity in memory address without instantiating it again to change its value or something like that.

But in your program, I can't see any benefit from using pointer because a C++ function, hMany in your case, internally re-instantiate the type of value in its argument, `int count' in your case.

As the other answers pointed out, you need to pass pointer of count to the function instead. In that case, the C++ function will similarly re-instantiate the type of value in its argument, but since the type is pointer, the program will have correct memory address of count inside of the C++ function and can correctly change the value of right identity.

Tae-Sung Shin
  • 20,215
  • 33
  • 138
  • 240