Simple Question: Pointers and Uninitialized Variables Explained

  • Thread starter Thread starter yungman
  • Start date Start date
  • Tags Tags
    Pointers
AI Thread Summary
The discussion revolves around the proper use of pointers in C++. The initial code fails because the pointer `p` is declared but not initialized, leading to an error when trying to dereference it. It is clarified that declaring `int* p;` only allocates memory for the pointer itself, not for the integer it points to. Until `p` is assigned a valid address, such as through `p = &x;`, it contains an undefined value. The conversation highlights that memory must be explicitly allocated using `new` if a pointer is to point to dynamically allocated memory. Various methods for initializing pointers and their associated memory are discussed, emphasizing that without proper initialization, dereferencing a pointer can lead to unpredictable behavior.
yungman
Messages
5,741
Reaction score
294
Why this doesn't work?
C++:
#include<iostream>
using namespace std;
int main()
{
    int* p;
    *p = 1;//error said uninitialized variable p used.
    cout << *p << endl;
    return 0;
}

I know if I do this, it works:
C++:
#include <iostream>
using namespace std;

int main ()
{
    int* p;
    int x = 10;
    p = &x;
    cout << *p << endl;

  return 0;
}
I thought when you declare a pointer int*p; you already allocate a memory for an integer pointed by p already.

Or int*p; only allocate memory for pointer p to store the address, that the address is not valid until using p = &x; to write the address of x into p?
Thanks
 
Last edited:
Technology news on Phys.org
yungman said:
Or int*p; only allocate memory for pointer p to store the address, that the address is not valid until using p = &x; to write the address of x into p?
Correct. Compare this to writing simply int x;. This says simply that x is a variable that is intended to contain an int. It doesn't store any particular value into x. At this point, x contains, in effect, a random bit pattern.

When you write simply int *p; this says that p is a variable that is intended to contain a pointer to an int. It doesn't store a particular value into p, that is, it doesn't make p point to any memory location in particular. At this point, p contains, in effect, a random bit pattern.
 
Thanks Jtbell, that clarified for me.
 
yungman said:
the address is not valid until using p = &x; to write the address of x into p?
That's one way to put a valid address into p. Another way, of course, is to allocate "new" memory explicitly. p = new int; allocates memory intended to hold an int and stores its address in p, but doesn't store any particular value in the newly-allocated memory, so in effect, *p gives you a random bit pattern.

To put something into the newly-allocated memory, you can initialize it when you allocate it: int *p = new int(x); declares p to be a pointer intended to point to an int, allocates an int-sized chunk of memory, and finally copies the value of x into the newly-allocated memory. Or you can initialize the new memory later: int *p = new int; *p = x;. Or you can separate all three steps: int *p; p = new int; *p = x;.
 
Thread 'Is this public key encryption?'
I've tried to intuit public key encryption but never quite managed. But this seems to wrap it up in a bow. This seems to be a very elegant way of transmitting a message publicly that only the sender and receiver can decipher. Is this how PKE works? No, it cant be. In the above case, the requester knows the target's "secret" key - because they have his ID, and therefore knows his birthdate.
Back
Top