Thread: Lot of questions.

Can you tell me if i made any small errors or if i did it completely wrong?

You made at least three mistakes, and I'll point out the first and third: i was not initialised, so the first printing of *p prints garbage; *p = 0 assigns 0 to the object pointed to by p, but at that point p points to a destroyed object. You mean to write p = 0;

The second mistake will be pointed out by the compiler.

EDIT:
Okay, there is a fourth mistake: x is not initialised either.

Originally Posted by Ryan0773

Would this mistake be the redeclaration of int*p?

Yes.

Originally Posted by Ryan0773

What do you meen they werent initialized?

They contain garbage values. You should write say,

Code:

int i = 123;

How could i fix the problem of redeclaration? When the compiler tells me thats the problem it doesn't have a suggestion that could fix it.

Well i guess they were garbage values (if that means that they didn't have any value) but that was just an example, i guess this is what it would look like with values:

Code:

#include <iostream>

using namespace std;

int main()
{
    int i(25 + 4);
    int x(4);
    int *p;
    p = &i;
    cout<< *p <<"\n";
    cout<< *p <<"\n";
    int *p = new int(x);
    p = &x;
    cout<< *p <<"\n";
    delete p;
    p = 0;
    cin.get();
}

the redeclaration error is still there though.


PS: You told me there were four error, the redeclaration, and the two garbage values...whats the last one?

Nvm, the last one was the p = 0 thing

Originally Posted by Ryan0773

How could i fix the problem of redeclaration?

Change:

Code:

int *p = new int(x);

to:

Code:

p = new int(x);

Originally Posted by Ryan0773

PS: You told me there were four error, the redeclaration, and the two garbage values...whats the last one?

I counted the garbage values as one each.

However, there is another mistake:

Code:

p = &x;

You should not be assigning the address of x to p since p points to dynamically allocated memory.

Originally Posted by Ryan0773

It worked, thanks alot!

No problem, but you might want to post your complete final code in case there are other (undetected) mistakes.

Originally Posted by Ryan0773

I still dont fully understand why a pointer would be needed

It is not needed in this case, actually

Originally Posted by Ryan0773

can they copy large amounts of code or just one simple integer?

The point is that a pointer points to an object. Copying a pointer is cheap even if copying the object (which could be composed of multiple sub-objects) is not.

There is still that last mistake. This:

Code:

p = new int(x);
p = &x;
cout<< *p <<"\n";

should be:

Code:

p = new int(x);
cout<< *p <<"\n";

Originally Posted by Ryan0773

What do you mean by cheap?

Few bytes to copy.

Originally Posted by laserlight

There is still that last mistake. This:

Code:

p = new int(x);
p = &x;
cout<< *p <<"\n";

should be:

Code:

p = new int(x);
cout<< *p <<"\n";

it doesn't seem to be a major mistake but i guess it would save some time (or is it a big mistake?)

Thanks again for your help!

I still dont really understand what you mean by cheap, is it less work for the computer? Like a shortcut?

Originally Posted by Ryan0773

I still dont really understand what you mean by cheap, is it less work for the computer? Like a shortcut?

Say you have a class that holds all the points of a 3d object. For a really detailed character, an object of that class might hold several hundred x, y and z coordinate triplets. Now say you want to pass an object of that class to the function that displays it on the screen.

The way variables are passed to functions, a copy is made of what you pass. So, for example, when you pass a simple int to a function, the program makes a copy of that int for the function to use. If you want to pass one of the 3d objects, it would make a copy of all that data, which could end up being several thousand bytes of data.

An alternative is to use a pointer to the object to tell the function where to look for the data. So now the program makes a copy of the pointer for the function to use, and then the function looks at the data that pointer is pointing to. Instead of making a copy of hundreds or thousands of bytes of data, it only has to copy a single pointer and the program is much quicker, especially if you are drawing a 3d scene with dozens of 3d objects having to be passed to the display function several times per second. With a pointer now, the program is working on processing your data rather than spending time copying it all over the place too.

In C++ we prefer to use references, but there are still times when pointers are needed. Under the hood, a reference is doing almost the same thing that a pointer does, but the program takes care of most of the dereferencing and other things that make pointers complicated so you can focus on making the program do what you want.

Originally Posted by Ryan0773

it doesn't seem to be a major mistake but i guess it would save some time (or is it a big mistake?)

It is a major mistake. By assigning the address of x to p, p now points to an object that will be automatically destroyed. As such, delete p; becomes a mistake. Furthermore, the object that was created on the previous line cannot be destroyed because there is no way to access it.

Perhaps have a look at: http://cslibrary.stanford.edu/104/
It's quite silly, but it explains the basics.
Also, the tutorial poisons your mind. I don't know why they insist on using T * in C++, but know that it is possible to write T*, as well.
Instead of:
int *p
You can write:
int* p
The later reinforces that the actual type of the variable is int*. If you dereference it, you get an int, but the pointer itself has a type, which is important.

You must also learn the difference between a value and an address. Pointers store addresses. Dereferencing addresses (ie pointers), you get the values.
Everything allocated by new must be freed with delete. It is not automatic. If you assign a new address to a pointer which carries an address from new, that address is lost forever and you cannot free the memory you allocated. That memory is now lost. It will still be there in the program, taking up space, without the ability of being used. It's a memory leak.

Here are a few uses of pointers:
- Dynamic memory allocation. new returns a pointer to the memory allocated (this is usually rare in C++, however, as std::vector & co is typically used for dynamic memory).
- Passing large objects around without copying (although, in C++, typically references are used for this).
- Allow multiple parts of your program to access the same data everywhere, without copying (then it would be multiple instances of that data).
- Allow multiple parts of your program to change some shared data and make sure all other parts get the new data (since all parts point to a single source of the data, if the data is then changed...).

Originally Posted by Ryan0773

So the pointer makes the program find the class with the 3d object and instead of the program copying the entire script of the object, using up thousands of bytes, the program gets the information through the pointer and uses it to get the object where you want it. Is that correct?

Yes, I think you got the gist of the idea.