c++ class pointer members acting strange(error)

Question

the public pointer member get assigned a strange value every time any function gets called.. it's not the constructor called because then the value should be changed or at least the pointer address should change pointer directs to the same address but the value changes what happened?

class whathappened {
public:
    int * a;
    whathappened();
    void print();
};

whathappened::whathappened() {
    int b = 23;
    a = &b;
}

void whathappened::print() {
    cout << a << " " << *a << endl;
}

int main() {
    whathappened sam;
    cout << sam.a << " " << *sam.a <<  endl;
    sam.print();
    cout << sam.a << " " << *sam.a << endl;
    while (1) {}
}

0133F650 23
0133F650 -858993460
0133F650 -858993460

Above code shouldn't even compile. Please take the habit of creating an MCVE (see site documentation) first. — Ulrich Eckhardt, Mar 24 '18 at 08:06

score 5 · Answer 1 · answered Mar 24 '18 at 02:47

5

The pointer a in your example points to a value that goes out of scope after the constructor. The pointer itself remains unchanged, but the value is likely overwritten by other values on the stack as more functions are called.

answered Mar 24 '18 at 02:47

Tyler

51
1
3

choxsword · Answer 2 · 2018-03-24T05:46:02.253

Anytime returning a reference to local function object will cause undefined behavior,so as pointer(in most cases).

standard N4727- 6.6.3/7

after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any glvalue that refers to the original object may be used but only in limited ways....The program has undefined behavior if: 1.the glvalue is used to access the object 2.....

In your example,it's called a dangling pointer.The a actually stores a pointer which points to a stack address,and during the function call or stack unwinding，the content you point to is always changing,depends on the current stack frame.

If any pointer is pointing the memory address of any variable but after some variable has deleted from that memory location while pointer is still pointing such memory location. Such pointer is known as dangling pointer and this problem is known as dangling pointer problem.

And about reference:

Although references, once initialized, always refer to valid objects or functions, it is possible to create a program where the lifetime of the referred-to object ends, but the reference remains accessible (dangling). Accessing such a reference is undefined behavior.

If you provide citations (section, paragraph) and even a link to the paragraph within the standard, that would be even more helpful than the text alone. — David C. Rankin, Mar 24 '18 at 05:09
@DavidC.Rankin I give a linkage to another discussion,which may be more precise and concrete. — choxsword, Mar 24 '18 at 05:10
Either way is fine, but the goal should always be guiding the user to the appropriate section of the primary document (or last publicly available draft) — David C. Rankin, Mar 24 '18 at 05:16

Swapnil · Answer 3 · 2018-03-24T14:13:53.190

If you allocate b on heap then the behavior will be expected, like

whathappened::whathappened() 
{
   int *b = new int(23); 
   a = b;
}

OR, you can just do

whathappened::whathappened() 
{
   a = new int(23); 
}

In this case no worry about the scope of b. By assigning a = b we have told a to point the memory which is on heap. And that will be valid till we don't call delete on a. To release the memory pointed by a you need to call delete. like

whathappened::~whathappened() 
{
    delete a;
}

c++ class pointer members acting strange(error)

3 Answers3