abstract classes not detected by compiler

B

Bjorn

I'm using interfaces in C++ by declaring classes with only pure virtual
methods. If then someone wants to implement the interface they
needs to inherit from the class. If the implementing class forgets to
implement some method I normally get a compile error(if the class is created
in some way of course). When using the Visual
Studio 6 compiler however, it does not generate a compile error in this
case:

- I have a implementing class A that inherits from an interface class. It
has not implemented all methods.
- The implementing class A is declared as an array in a container class. The
container class is created with new.

The compiler do not generate any errors, but I will of course get a runtime
error when a method with no implementation is called("pure function call" or
something). If the container class declares A as a pointer(and performs new
on it) or as a non-array variable, then the compiler generates compile
errors, but not if it is declared as an array.

So, my question is: is it a compiler fault, if it does not find out that an
abstract class is created(which is the case here since all methods are not
implemented)? Or should it be considered as normal that the compiler can not
find out cases like this(i.e more complicated cases).

/Bjorn
 
K

Karthik Kumar

Bjorn said:
I'm using interfaces in C++ by declaring classes with only pure virtual
methods. If then someone wants to implement the interface they
needs to inherit from the class. If the implementing class forgets to
implement some method I normally get a compile error(if the class is created
in some way of course). When using the Visual
Studio 6 compiler however, it does not generate a compile error in this
case:

- I have a implementing class A that inherits from an interface class. It
has not implemented all methods.
- The implementing class A is declared as an array in a container class. The
container class is created with new.
Click to expand...

Posting some code is always better than describing the same.

#include <cstdlib>

class Base {
public:
virtual int donothing1(void) = 0;
virtual int donothing2(void) = 0;
};

class A: public Base {
public:
virtual int donothing1(void) {
return 1;
}

//'donothing2' not implemented
};

class Container {
private:
A obj[100];
};

int main() {
Container * contain = new Container;
delete contain;
return EXIT_SUCCESS;
}


The compiler errors out as follows -

d:\classA.cpp(20): error C2259: 'A' : cannot instantiate abstract class

The compiler do not generate any errors, but I will of course get a runtime
error when a method with no implementation is called("pure function call" or
Click to expand...

It is not possible to call a method with no implementation, unless
there is a problem with the build process. Try cleaning the relevant
object files and building the entire thing again.

something). If the container class declares A as a pointer(and performs new
on it)
Click to expand...

The compiler behavious is entirely determined by the type of the
object you dynamically bind to a pointer to A.

A * ptr ; // compiler is happy. you are not
// instantiating anything here.

ptr = new A ; // Assuming not all methods of A are implemented,
// compiler would error out.
or as a non-array variable, then the compiler generates compile
errors, but not if it is declared as an array.

So, my question is: is it a compiler fault,
Click to expand...

Post some code to understand things better.
if it does not find out that an
abstract class is created(which is the case here since all methods are not
implemented)? Or should it be considered as normal that the compiler can not
find out cases like this(i.e more complicated cases).
Click to expand...

A compiler can definitely find a scenario where not all methods of a
class are implemented.
 
V

Victor Bazarov

Bjorn said:
[...]
So, my question is: is it a compiler fault, if it does not find out that an
abstract class is created
Click to expand...

_Created_? REALLY? Where? You claim that "the container class declares
A ... as an array". Could you show how you do that?
(which is the case here since all methods are not
implemented)? Or should it be considered as normal that the compiler can not
find out cases like this(i.e more complicated cases).
Click to expand...

------------------------------------ example 1 : no big deal
struct ABC { // abstract
virtual void foo() = 0;
};

struct CC : ABC { // concrete
void foo() {}
};

int main() {
ABC *pa; // a pointer to ABC object, uninitialised, unused
}
------------------------------------ example 2 : still no big deal
struct ABC { // abstract
virtual void foo() = 0;
};

struct CC : ABC { // concrete
void foo() {}
};

int main() {
ABC *pa[10] = {0}; // an array of pointers to ABC, all 0, unused
}
------------------------------------ example 3 : undefined behaviour
struct ABC { // abstract
virtual void foo() = 0;
};

struct CC : ABC { // concrete
void foo() {}
};

int main() {
ABC *pa; // an uninitialised pointer to ABC
pa->foo(); // an attempt to use that uninitialised pointer - BOOM!
}
------------------------------------ example 4 : undefined behaviour
struct ABC { // abstract
virtual void foo() = 0;
};

struct CC : ABC { // concrete
void foo() {}
};

int main() {
ABC *pa[10]; // an array of uninitialised pointers to ABC
pa[0]->foo(); // an attempt to use an uninitialised pointer - BOOM!
}
------------------------------------ example 5 : no big deal
struct ABC { // abstract
virtual void foo() = 0;
};

struct CC : ABC { // concrete
void foo() {}
};
#include <list>
int main() {
std::list<ABC*> lst; // a standard list of pointers to ABC - unused
}
------------------------------------
All examples should compile fine (although I didn't check, just typed
them in).

As you can see, if there is no attempt to _instantiate_ the abstract
class, it's still possible to have undefined behaviour, but not due to
the call to the pure function.

The C++ language prohibits _creation_ of _object_ of a class that is
abstract. If your program doesn't create any objects, how can it have
undefined behaviour? And if you don't create any objects in your code,
how can the compiler know what your intentions are?

Victor
 
T

Thomas Maier-Komor

Bjorn said:
I'm using interfaces in C++ by declaring classes with only pure virtual
methods. If then someone wants to implement the interface they
needs to inherit from the class. If the implementing class forgets to
implement some method I normally get a compile error(if the class is created
in some way of course). When using the Visual
Studio 6 compiler however, it does not generate a compile error in this
case:

- I have a implementing class A that inherits from an interface class. It
has not implemented all methods.
- The implementing class A is declared as an array in a container class. The
container class is created with new.

The compiler do not generate any errors, but I will of course get a runtime
error when a method with no implementation is called("pure function call" or
something). If the container class declares A as a pointer(and performs new
on it) or as a non-array variable, then the compiler generates compile
errors, but not if it is declared as an array.

So, my question is: is it a compiler fault, if it does not find out that an
abstract class is created(which is the case here since all methods are not
implemented)? Or should it be considered as normal that the compiler can not
find out cases like this(i.e more complicated cases).

/Bjorn
Click to expand...

#include <list>

struct ABC {
virtual void x() = 0;
};

std::list<ABC *> mylist; // this is OK
std::list<ABC> anotherlist; // this should generate a compile-time error

Tom
 
D

DaKoadMunky

It is not possible to call a method with no implementation, unless
there is a problem with the build process
Click to expand...

Not necessarily true...

struct Abstract
{
Abstract()
{
NonVirtual();
}

void NonVirtual()
{
PureVirtual();
}

virtual void PureVirtual()=0;
};

struct Concrete : public Abstract
{
void PureVirtual()
{
}
};

int main()
{
Concrete c;

return 0;
}

Using MSVC++.NET a run-time error indicates that a pure virtual function was
called.

I don't know what the language standard says regarding this. I am guessing it
is undefined behavior? Does the standard discuss attempts to invoke pure
virtual functions directly or indirectly from a base class constructor (or
destructor?)
 
B

Bjorn

Hi again,

I provide a code example below to clarify things. The compiler version I use
is:

Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804 for 80x86

The following compiles without error, but of course gives a run time error
since all methods are not implemented.
#include "stdafx.h"

class Base {

public:

virtual void func1() = 0;

virtual void func2() = 0;

};

class SubClassToBase : public Base {

virtual void func1() {

int i = 7;

}

};

class Container {

public:

Base* getBase() {

return b;

}

private:

SubClassToBase b[1];

};

int main(int argc, char* argv[])

{

Container* c = new Container;

c->getBase()->func2();

// This will cause a runtime error, since

// func2() is not impemented

// The compiler does not generate error

return 0;

}

/Bjorn



Karthik Kumar said:
Bjorn said:
I'm using interfaces in C++ by declaring classes with only pure virtual
methods. If then someone wants to implement the interface they
needs to inherit from the class. If the implementing class forgets to
implement some method I normally get a compile error(if the class is created
in some way of course). When using the Visual
Studio 6 compiler however, it does not generate a compile error in this
case:

- I have a implementing class A that inherits from an interface class. It
has not implemented all methods.
- The implementing class A is declared as an array in a container class. The
container class is created with new.
Click to expand...

Posting some code is always better than describing the same.

#include <cstdlib>

class Base {
public:
virtual int donothing1(void) = 0;
virtual int donothing2(void) = 0;
};

class A: public Base {
public:
virtual int donothing1(void) {
return 1;
}

//'donothing2' not implemented
};

class Container {
private:
A obj[100];
};

int main() {
Container * contain = new Container;
delete contain;
return EXIT_SUCCESS;
}


The compiler errors out as follows -

d:\classA.cpp(20): error C2259: 'A' : cannot instantiate abstract class

The compiler do not generate any errors, but I will of course get a runtime
error when a method with no implementation is called("pure function
Click to expand...
call" or

It is not possible to call a method with no implementation, unless
there is a problem with the build process. Try cleaning the relevant
object files and building the entire thing again.

something). If the container class declares A as a pointer(and performs new
on it)
Click to expand...

The compiler behavious is entirely determined by the type of the
object you dynamically bind to a pointer to A.

A * ptr ; // compiler is happy. you are not
// instantiating anything here.

ptr = new A ; // Assuming not all methods of A are implemented,
// compiler would error out.
or as a non-array variable, then the compiler generates compile
errors, but not if it is declared as an array.

So, my question is: is it a compiler fault,
Click to expand...

Post some code to understand things better.
if it does not find out that an
abstract class is created(which is the case here since all methods are not
implemented)? Or should it be considered as normal that the compiler can not
find out cases like this(i.e more complicated cases).
Click to expand...

A compiler can definitely find a scenario where not all methods of a
class are implemented.
Click to expand...
 
O

Oleg Polikarpotchkin

Not necessarily true...

struct Abstract
{
Abstract()
{
NonVirtual();
}

void NonVirtual()
{
PureVirtual();
}

virtual void PureVirtual()=0;
};

struct Concrete : public Abstract
{
void PureVirtual()
{
}
};

int main()
{
Concrete c;

return 0;
}

Using MSVC++.NET a run-time error indicates that a pure virtual function was
called.
Click to expand...

It's normal: "Concrete" object vtable is not yet properly constructed.
I have seen the comments on this situation, but where it was ?...
 
T

Thomas Maier-Komor

Oleg said:
It's normal: "Concrete" object vtable is not yet properly constructed.
I have seen the comments on this situation, but where it was ?...
Click to expand...

a constructor cannot call any virtual functions. so any call to a
virtual function will be non-virtual. In consequence calling a
pure virtual function should be rejected by the compiler (IIRC)...
 
K

Karthik Kumar

Bjorn said:
Hi again,

I provide a code example below to clarify things. The compiler version I use
is:

Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8804 for 80x86

The following compiles without error, but of course gives a run time error
since all methods are not implemented.
#include "stdafx.h"

class Base {

public:

virtual void func1() = 0;

virtual void func2() = 0;

};

class SubClassToBase : public Base {

virtual void func1() {

int i = 7;

}

};

class Container {

public:

Base* getBase() {

return b;

}

private:

SubClassToBase b[1];

};

int main(int argc, char* argv[])

{

Container* c = new Container;

c->getBase()->func2();

// This will cause a runtime error, since

// func2() is not impemented

// The compiler does not generate error

return 0;

}

/Bjorn
Click to expand...

Checked with the two compilers that I have access to.

class Base {

public:

virtual void func1() = 0;
virtual void func2() = 0;

};

class SubClassToBase : public Base {

virtual void func1() {
int i = 7;
}
};

class Container { //g++ errors out here

public:

Base* getBase() {
return b;
}

private:
SubClassToBase b[1]; // VC++ .NET 2003 errors out here.
};

int main(int argc, char* argv[]) {

Container* c = new Container;
c->getBase()->func2();

// This will cause a runtime error, since
// func2() is not impemented
// The compiler does not generate error

return 0;
}


gcc 3.4.2.

C:\>g++ -ansi -pedantic pure_virtual.cpp
pure_virtual.cpp:17: error: cannot declare field `Container::b' to be of
type `SubClassToBase'
pure_virtual.cpp:17: error: because the following virtual functions
are abstract:
pure_virtual.cpp:6: error: virtual void Base::func2()


VC++ .NET is not happy either.

C:\pure_virtual.cpp(26) : error C2259: 'SubClassToBase' : cannot
instantiate abstract class
due to following members:
'void Base::func2(void)' : pure virtual function was not defined
C:\pure_virtual.cpp(6) : see declaration of 'Base::func2'


<OT>

U:\>cl
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.

</OT>
 
M

Markus Elfring

a constructor cannot call any virtual functions. so any call to a
virtual function will be non-virtual. In consequence calling a
pure virtual function should be rejected by the compiler (IIRC)...
Click to expand...

Which rules from the specifications show this restriction?
Would you like to adjust your wording?

How does your statement fit to the descriptions in the chapter "Item
25: Virtualizing constructors and non-member functions" from the book
"More Effective C++"?

Regards,
Markus
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

Setting array size with a variable - What does the C compiler do? 3
Regarding for Stand Alone Java Compiler? 2
Pure Abstract Classes 4
Abstract Classes 1
Implementation of abstract classes 9
Positioning student result by ranking grade 1
ABCs (abstract base classes) and linkage problems 4
About abstract classes and Inheritance 3

Members online

No members online now.
Total: 41 (members: 0, guests: 41)
Robots: 647

Forum statistics

Threads
473,769
Messages
2,569,582
Members
45,057
Latest member
KetoBeezACVGummies

Latest Threads

Top