Pointers without allocation

Hello,

Code:

---

class foo{
public:
void fun(){ /* do something */ };
};

int main(){

foo *pF;
pF->fun();

return 0;
}

---

How is fun() called when nothing has been allocated to the pointer? In c++ classes we've been taught that we need to allocate memory with the 'new' keyword, so how is this legal c++? I'm just finding out about this and I don't know what it's called, so I can't search for it. I don't remember reading anything about it in the books. Does this not cause data loss when nothing has been assigned to pF? what is its use?

The code is syntactically valid, but it is wrong to call a member function of an object that does not exist.

Quote:

---

so how is this legal c++?

---

It's not. Just because something compiles doesn't mean it's legal.

Also, turn up the warning level on your compiler - you definitely should get a stern warning for this code about using uninitialized variables.

If the function does not access member data, then it will probably run (though it's still undefined). The problem is that typically functions and data are separate. Functions recieve and extra argument (the this pointer), which points to where the class data exists. So if you call a function in an unitialized pointer, the this pointer sent to the function will be garabage.

So just because you can away with it doesn't mean you should. It's definitely not legal.

Code:

---

class foo{
public:
void fun(){ /* do something */ };
};

int main(){

foo *pF;
pF->fun();

return 0;
}

---

The code looks ok to me. Doesn't the compiler know that it's creating a pointer to a class and not a basic variable? Then you just call the member function fun() as a pointer.

No, because the pointer doesn't point to a valid memory block with allocated memory.
You need to read up on pointers, my friend. They aren't magical. They don't somehow, magically allocate memory for you and point to a valid address.

So why does the code work?

As I explained. First, it's undefined behavior.
Second, it may work if it doesn't access member data because functions are not stored at the this pointer, but member data is.

Quote:

---

Originally Posted by Caverage

So why does the code work?

---

Because the way it is implemented by the compiler is the same as if it were a non-member function with a hidden parameter called 'this'.
I.e. Instead of:

Code:

---

class foo{
public:
void fun(){ /* do something */ };
};

---

think of it as:

Code:

---

class foo{
};
void fun(foo *this){ /* do something */ };

---

except that you call it like this:

Code:

---

pF->fun();

---

instead of this:

Code:

---

fun(pF);

---

The later would not crash because fun doesn't do anything with the 'this' pointer. The same reasoning applies to the original code, because the differences between the two are usually just superficial.

That's not to say that this is how ALL compilers implement member functions.

So, what iMalc is saying (and I agree) is that the compiler can [most of the time, depending on the design of the compiler] figure out where fun() is without accessing the the pointer itself. Accessing the pointer in this case would MOST likely cause a crash, but calling a function that doesn't do anything within the object that "this" points to, then you'd be OK. Of course, most of the meaningful member functions in a class object will need to access the content of the object. So this is only going to work for member functions that doesn't actually use the content of the class [and subject to the implementation of the compiler].

Of course, accessing an uninitialized pointer isn't GUARANTEED to crash things. The system may not have memory protection in a way that it causes a crash when a "random" address is accessed [e.g. DOS or DOS-emulation in Windows], and it may be that the memory address that happens to be in the pointer is actually a valid memory location (just not given to your object, so therefore not valid for this purpose).

--
Mats

My apologies everyone. I've been talking to some Qt programmers, and I've realized that I posted a really bad example. I'm reading a book on programming with Qt4, and I was trying to understand a function call in one of their examples. Here it is:

Code:

---

void MainWindow::closeEvent(QCloseEvent *event)
{
    if (okToContinue()) {
        writeSettings();
        event->accept();
    } else {
        event->ignore();
    }
}

---

MainWindow is my class, which is derived from QMainWindow. QMainWindow is derived from QWidget. closeEvent is a virtual function in QWidget, and I never have to call it directly cause it gets called automatically. The Qt guys told me that the event parameter has already been prepared. So I guess everything makes sense now?