struct A
{
virtual void foo(); // unused and unimplemented
virtual void bar () {}
};
int main ()
{
A obj; // ok
obj.bar(); // <-- added this edition
A* pm = (A*)malloc(sizeof(A)); // ok
A* pn = new A; // linker error
}
For objects on stack it works fine. But for allocation on heap with new (not malloc), it gives linker error:
undefined reference to `vtable for A'
Firstly, this code is not compilable, since in C++ void * cannot be implicitly converted to A *. An explicit cast is required.
Secondly, the example with malloc is completely irrelevant. malloc allocates raw memory, with has absolutely no relation to any specific types. In this case malloc knows noting about any A and it does not create an object of type A.
For this reasons the real example for this question should look as follows
struct A
{
virtual void foo(); // unused and unimplemented
virtual void bar () {}
};
int main ()
{
A obj; // ok
A* pn = new A; // linker error
}
And the question is why the first declaration produces no liker error while the second one does.
From the formal point of view, your program is invalid because it violates formal requirements of C++ language (specifically ODR). In practice, both declarations could or should produce the same error, since in both cases the object formally requires a pointer to VMT. In this case VMT cannot be created, since some functions are undefined. However, the first declaration simply slips through just because the compiler was able to optimize-out all references to VMT for the first declaration (and not for the second). It is also quite possible that the compiler was able to optimize-out the whole obj object, since it is not referenced anywhere else.
In GCC (since you appear to be using GCC) it is easy to trigger the same error for the first declaration as well
struct A
{
virtual void foo(); // unused and unimplemented
virtual void bar () {}
};
int main ()
{
A obj; // linker error
A *p = &obj;
p->bar();
}
The above code will produce the same linker error in GCC even though the undefined function foo is still not used in this code.
In other words, it is simply a matter of adding sufficient amount of code to make the compiler believe that the object's VMT is needed. The difference in behavior between the declarations has nothing to do with C++ language in this case. It is just an implementation issue specific to your compiler.
obj.bar() right? BTW, +1 for a nice explanation for a complicated matter. –
Elviselvish p->bar(). Thank you for pointing it out. Fixed. –
Rejoin A obj; ideone.com/aYf5W –
Tatiania Because malloc does not call (or attempt to call in this case) A's constructor, whereas new does.
This code compiles and notes where linker errors occur with GCC:
#include <cstdlib>
struct A
{
virtual void foo(); // unused and unimplemented
virtual void bar () {}
};
int main ()
{
A obj; // linker error
A* pm = (A*) malloc(sizeof(A)); // ok
A* pn = new A; // linker error
}
A obj; also call A's constructor? So this alone can't be the reason, right? (Happy to be shown the error in my thinking.) –
Elviselvish A obj; does produce a linker error. OP, can you verify or state your compiler/linker? –
Elviselvish malloc. That line with malloc shouldn't even be there (not even mentioning that it is not compilable). The question is about the difference between new-ed object and locally declared object. –
Rejoin A obj. Of course, it could be a matter of optimization settings. –
Rejoin new. The standard requires that all used functions are defined in the program §3.2/3 Every program shall contain exactly one definition of every non-inline function or object that is used in that program; no diagnostic required. . For virtual functions, the definition of used is §3.2/2 A virtual member function is used if it is not pure.. The fact that your compiler did not complain when the variable was allocated in the stack falls in the no diagnostics required bit of the rule. Maybe this should be an answer... –
Frans A obj; (Mine does and Neil's does) and some aren't (OP and AndreyT) due to optimization, and that this is a part of the standard that is up for interpretation? If obj is used, then it definitely will cause a linker error. –
Elviselvish A obj; and 2nd obj is not unused (to let compiler optimize it away). Still question remains the same. –
Tatiania Firstly, this code is not compilable, since in C++ void * cannot be implicitly converted to A *. An explicit cast is required.
Secondly, the example with malloc is completely irrelevant. malloc allocates raw memory, with has absolutely no relation to any specific types. In this case malloc knows noting about any A and it does not create an object of type A.
For this reasons the real example for this question should look as follows
struct A
{
virtual void foo(); // unused and unimplemented
virtual void bar () {}
};
int main ()
{
A obj; // ok
A* pn = new A; // linker error
}
And the question is why the first declaration produces no liker error while the second one does.
From the formal point of view, your program is invalid because it violates formal requirements of C++ language (specifically ODR). In practice, both declarations could or should produce the same error, since in both cases the object formally requires a pointer to VMT. In this case VMT cannot be created, since some functions are undefined. However, the first declaration simply slips through just because the compiler was able to optimize-out all references to VMT for the first declaration (and not for the second). It is also quite possible that the compiler was able to optimize-out the whole obj object, since it is not referenced anywhere else.
In GCC (since you appear to be using GCC) it is easy to trigger the same error for the first declaration as well
struct A
{
virtual void foo(); // unused and unimplemented
virtual void bar () {}
};
int main ()
{
A obj; // linker error
A *p = &obj;
p->bar();
}
The above code will produce the same linker error in GCC even though the undefined function foo is still not used in this code.
In other words, it is simply a matter of adding sufficient amount of code to make the compiler believe that the object's VMT is needed. The difference in behavior between the declarations has nothing to do with C++ language in this case. It is just an implementation issue specific to your compiler.
obj.bar() right? BTW, +1 for a nice explanation for a complicated matter. –
Elviselvish p->bar(). Thank you for pointing it out. Fixed. –
Rejoin A obj; ideone.com/aYf5W –
Tatiania You cannot leave a virtual function unimplemented, even if it's 'unused' (because it's in fact used by the vtable). This is the bug in the code.
The bug manifests itself in this particular fashion because of a peculiar implementation of vtables in the compiler. You have left unimplemented the first virtual function. The compiler inserts the vtable whenever it sees the implementation of the first virtual function of the class. Since there isn't any, there's no vtable.
If you leave the second function unimplemented, the linker will complain about that specific function, not about the vtable.
[edit]
Your compiler probably optimized-out a copy of A on the stack, that's the reason the linker didn't complain.
The malloc line doesn't actually reference an object of type A, that's why it doesn't create a linker problem. There's another problem with this line though: it should not compile. malloc returns void* which does not convert to other types of pointer without a cast.
The standard requires exactly one implementation of A::foo if A is
instantiated anywhere in the program. Regardless of whether the
instantiation is through the declaration of a local variable or through
a new expression. However, no diagnostic is required if this rule is
broken; if you provide no declaration, or if you provide two or more,
it's simply undefined behavior. Anything the compiler does is
"correct". In this case, what it probably happening is:
the constructor of A is inline, so the code which initializes the vptr (and triggers the instantiation of the vtable) is fully visible to the compiler,
since all uses of the object are visible to the compiler, it can see that the vptr is never used, so it simply suppresses it.
and with no vptr, no vtable need be generated, so there is no reference to the virtual function.
In sum, it depends on how the compiler optimizes; you might get an error for both the local declaration and the new expression, or for neither, or for one and not the other. And it might depend on the optimization options, or whatever. As far as C++ is concerned, it might depend on the phases of the moon, and instead of an error, you might simply get code which crashed when you ran it (but the scenarios I stated first are the most likely).
Unusedness is irrelevant. Define all virtual functions. It's as simple as that.
Your automatic storage duration object (what you've chosen to call an object "on the stack") is not used [polymorphically], so you get no diagnostic. That doesn't make it right.
virtual method unimplemented and that's why this came to me. The problem is why language doesn't allow it. –
Tatiania static keyword would have to be used (or the variable would have to be at namespace level) –
Frans © 2022 - 2024 — McMap. All rights reserved.
malloc. – RejoinA obj;ideone.com/AYYle – Tatianiamalloc()how can it be a fake code just for that ? I have edited it though. – Tatiania