Why an instance of Abstract class cannot be created

Question

1.00/5 (4 votes)

See more:

#include

C#

<iostream>

using namespace std;

class Base
{
 public:
    virtual void diplay() = 0;
};

//Main function
int main()
{
Base B;
}

Posted 14-Jul-15 5:02am

Member 11836730

Add a Solution

Comments

[no name] 14-Jul-15 11:15am

https://msdn.microsoft.com/en-us/library/k535acbf(VS.71).aspx

CPallini 15-Jul-15 9:09am

In my opinion, that's similar to asking: "why a const value cannot change?"

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Accepted Answer · 2015-07-14T05:20:00

The whole idea of an abstract class is that it is "an abstraction" - it defines what the concrete classes must do.

If you could instantiate it, it wouldn't be an abstract class, it would be a "normal" class that didn't work because some of the vital bits were missing!

It's like a car: your car is a Ford, my car is a Mercedes. "Car" is an abstract class that doesn't exist on it's own, but it can contain functions which apply to all Car objects: "Accelerate", "Brake", "Steer", and "Start" for example. But you need to have a motor manufacturer in order to drive: "Ford" and "Mercedes" are derived from "Car" but they implement the "Start" method (by turning a key in the one case, by pressing a button in the other)

See here for another explanation: http://www.studytonight.com/cpp/abstract-class-and-pure-virtual.php[^]

Sergey Alexandrovich Kryukov · Accepted Answer · 2015-07-14T05:36:00

Because this is the purpose of the notion, to prevent instantiation of abstract classes.

In this case, the class can be called abstract, because it contains at least one pure virtual function (the one with "= 0" following the declaration, display in the code sample), which also can be called "abstract". Imagine what would have happened if you could instantiate such class:

C++

Base b;
b.display(); // crash!

Note that it is impossible for the compiler to deny compilation of b.display(), because this line could be valid if the runtime type of b wasn't Base, but was a class derived from Base, with properly overridden display(). And this is the whole idea of the purpose of abstract classes: to serve as a base class for derived classes and provide a common interface for them. In such cases, the compile-time type of instantiated object could be the base class, but all actual runtime types should be all non-abstract. This is enforced by having the compiler preventing instantiation of abstract types (class or struct).

[EDIT]

Thanks to the important comments by Stefan Lang (please see below), I improved the answer. I removed the mention that the pure virtual function has no implementation, because it can have one: http://en.cppreference.com/book/intro/abstract_classes[^].

Adding the implementation does not make a type non-abstract; the implementation can be used for whatever purpose in the derived classes. When the using code calls this function, such outside call will always be dispatched to one of the implementations of this function in one of derived classes, because overriding of the pure virtual function is required to make a non-abstract type; and only a non-abstract type can be instantiated.

Also, in my comment to the question, I explained in what cases the compiler cannot deny the compilation of b.display(). Of course, in principle, the compiler could analyze and find out that this line makes no sense, based on the declaration of b. But let's consider the cases when this is not so.

For example,

C++

class Base {/* ... */} // abstract, same as in the inquirer's code sample
class Derived : public Base {/* ... */} // display implemented, non-abstract

Let's say we have function

C++

void SomeExample(Base* b) { b->display(); }

or

C++

void SomeExample(Base& b) { b.display(); }

Should it compile? Yes, always. This is because the function does not "know" the runtime type of b. It can be called with any of the derived types, and Base serves as a common interface for them.

Note that, in the last code sample, the line which should compile is exactly the same as in the very first "impossible" code sample: b.display(); but in this context it should compile and will work, exactly by the reason I started with: the runtime type of b cannot be Base, the compiler will prevent instantiation of an abstract class.

—SA Codeproject Bot

Why an instance of Abstract class cannot be created

2 solutions

Solution 1

Solution 2

Add your solution here

Preview 0