blocks|key|1131020|text|抽象类不能实例化，而具体类可以实例化。抽象类充当派生类的“蓝图”，即可以实例化的类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1131021|例如，Car类(抽象)，而Audi+S4类(从Car派生)是一个具体的实现。|offset|length|style|CODE|1131022|entityMap^0|0|3|3|D|7|N|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|I|$]]

An abstract class can't be instantiated whilst a concrete one can. An abstract class serves as "blueprint" for derived classes, ones that can be instantiated.

E.g. <code>Car</code> class (abstract) whilst <code>Audi S4</code> class (deriving from <code>Car</code>) class is a concrete implementation.

blocks|key|1131076|text|具体类是可用于创建对象的类。抽象类不能用于创建对象(必须扩展抽象类并使具体类能够创建对象)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1131077|假设有一台机器可以“盖章”原材料和制造一辆汽车。stamper是一个具体的类。由此，我们可以创建汽车对象。抽象类将是冲压机的蓝图。你不能根据冲压机的蓝图制造汽车，你需要首先根据蓝图制造冲压机类。|1131078|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A concrete class is a class that can be used to create an object. An abstract class cannot be used to create an object (you must extend an abstract class and make a concrete class to be able to then create an object).

Pretend that there is a machine that can "stamp" raw materials and make a car. The stamper is a concrete class. From this we can create car objects. An abstract class would be the blueprints for the stamper. You cannot make cars from the blueprints of the stamper, you need to make the stamper class first from the blueprints.

blocks|key|1346551|text|使用抽象类的一个很好的例子是当你构建一个非常模块化的东西的时候。假设您正在使用一个数据存储，但该数据可以是MySQL数据库、SQLite数据库、XML文件或纯文本。为了在您的代码中保留这种多功能性，您可以创建一个类AbstractDatastore，它定义您想要用来从数据存储中获取信息的公共方法。然后，创建特定的AbstractDatastore实现，如XmlDatastore、SQLiteDatastore等。然后，您的程序只需要知道它正在获取一个AbstractDatastore，并且它必须具有在AbstractDatastore中定义的那些函数，但是它并不知道或关心数据是如何存储或检索的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1346552|entityMap^0|2Z|H|4D|H|4Y|C|5B|F|6B|H|71|H|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|G|$]]

A good example of using an abstract class is when you're building something very modular. Let's say you're working with a data store, but that data could be in a MySQL database, SQLite database, XML file, or plain text. To retain this versatility in your code, you can create a class <code>AbstractDatastore</code> that defines the public methods you want to use to get information from the datastore. Then you create your specific implementations of the <code>AbstractDatastore</code>, such as <code>XmlDatastore</code>, <code>SQLiteDatastore</code>, etc. Then, your program just needs knows it's getting an <code>AbstractDatastore</code> and that it must have those functions defined in <code>AbstractDatastore</code> but it doesn't know or care how the data is stored or retrieved.

blocks|key|1131325|text|基类与派生类是抽象类与具体类的正交概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1131326|基类是不从任何其他类继承的类。派生类确实继承自另一个类。|1131327|抽象类是具有一个或多个纯虚函数的类。一个具体的类没有纯粹的优点。|1131328|抽象类可以是基类，也可以是派生类(它是从另一个抽象类派生的)。具体类也可以是基类，也可以是派生类。您甚至可以通过向派生类添加纯虚函数，从具体类派生抽象类。但在一般情况下，有一个抽象基类和一个或多个具体派生类。|1131329|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Base-class vs. derived class is an orthogonal concept to abstract class vs. concrete class. 

A base class is one that does not inherit from any other class. A derived class does inherit from another class. 

An abstract class is one that has one or more pure virtual functions. A concrete class has no pure virtuals. 

An abstract class can be either a base class or a derived class (it is derived from another abstract class). A concrete class can also be either base or derived. You can even derive an abstract class from a concrete class, by adding a pure virtual function to the derived class. But in general use, there is one base abstract class and one or more concrete derived classes.

blocks|key|1346785|text|抽象类是为其声明了一个或多个方法但未定义的类，这意味着编译器知道这些方法是类的一部分，但不知道为该方法执行什么代码。这些被称为抽象方法。下面是一个抽象类的例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1346786|class+shape+{
public:
++virtual+void+draw()+=+0;
};|code-block|syntax|javascript|1346787|它声明了一个抽象类，指定如果类是具体的，那么该类的任何后代都应该实现draw方法。你不能实例化这个类，因为它是抽象的，毕竟，如果你调用成员draw，编译器将不知道要执行什么代码。因此，您不能执行以下操作：|1346788|shape+my_shape();
my_shape.draw();|1346789|为了能够实际使用draw方法，您需要从这个抽象类派生类，该类实现了draw方法，使类具体化：|1346790|class+circle+:+public+shape+{
public:
++circle(int+x,+int+y,+int+radius)+{
++++/*+set+up+the+circle+*/
++}
++virtual+draw()+{
++++/*+do+stuff+to+draw+the+circle+*/
++}
};

class+rectangle+:+public+shape+{
public:
++rectangle(int+min_x,+int+min_y,+int+max_x,+int+max_y)+{
++++/*+set+up+rectangle+*/
++}
++virtual+draw()+{
++++/*+do+stuff+to+draw+the+rectangle+*/
++}
};|1346791|现在，您可以实例化具体对象circle和rectangle，并使用它们的绘图方法：|1346792|circle+my_circle(40,+30,+10);
rectangle+my_rectangle(20,+10,+50,+15);
my_circle.draw();
my_rectangle.draw();|1346793|当然，现在的问题是，你为什么要这样做？难道你不能定义circle和rectangle类并去掉整个shape类吗？你可以，但这样你就不能利用他们的遗产了：|1346794|std::vector<shape*>+my_scene;
my_scene.push_back(new+circle(40,+30,+10));
my_scene.push_back(new+rectangle(20,+10,+50,+15));
std::for_each(my_scene.begin(),+my_scene.end(),+std::mem_fun_ref(&shape::draw)|1346795|这段代码让你将所有的形状收集到一个容器中。如果场景中有许多形状和许多不同的形状，这会使它变得容易得多。例如，我们现在可以一次绘制所有的形状，这样做的代码甚至不需要知道我们拥有的不同类型的形状。|1346796|现在我们终于需要知道为什么形状的绘制函数是抽象的，而不仅仅是一个空函数，也就是为什么我们不直接定义：|1346797|class+shape+{
public:
++virtual+void+draw()+{
++++/*+do+nothing+*/
++}
};|1346798|这样做的原因是，我们并不真的想要shape类型的对象，它们无论如何都不是真实的东西，它们将是抽象的。因此，为draw方法定义一个实现是没有任何意义的，即使是一个空的。使shape类抽象可以防止我们错误地实例化shape类，或者错误地调用基类的空绘制函数而不是派生类的绘制函数。实际上，我们为任何想要像形状一样行为的类定义了一个接口，我们说任何这样的类都应该有一个看起来像我们已经指定的绘制方法。|1346799|回答你的最后一个问题，没有“普通派生类”这样的东西，每个类都是抽象的或具体的。有抽象方法的类是抽象的，没有抽象方法的类是具体的。这只是一种区分两种类型类的方法。基类可以是抽象的，也可以是具体的；派生类可以是抽象的，也可以是具体的：|1346800|class+abstract_base+{
public:
++virtual+void+abstract_method1()+=+0;
++virtual+void+abstract_method2()+=+0;
};

class+concrete_base+{
public:
++void+concrete_method1()+{
++++/*+do+something+*/
++}
};

class+abstract_derived1+:+public+abstract_base+{
public:
++virtual+void+abstract_method3()+=+0;
};

class+abstract_derived2+:+public+concrete_base+{
public:
++virtual+void+abstract_method3()+=+0;
};

class+abstract_derived3+:+public+abstract_base+{
public:
++virtual+abstract_method1()+{
++++/*+do+something+*/
++}
++/*+note+that+we+do+not+provide+an+implementation+for
+++++abstract_method2+so+the+class+is+still+abstract+*/
};

class+concrete_derived1+:+public+concrete_base+{
public:
++void+concrete_method2()+{
++++/*+do+something+*/
++}
};

class+concrete_derived2+:+public+abstract_base+{
public:
++virtual+void+abstract_method1()+{
++++/*+do+something+*/
++}
++virtual+void+abstract_method2()+{
++++/*+do+something+*/
++}
++/*+This+class+is+now+concrete+because+no+abstract+methods+remain+*/
};|1346801|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1C|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|1N|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1O|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|18|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|19|$]]

An abstract class is a class for which one or more methods are declared but not defined, meaning that the compiler knows these methods are part of the class, but not what code to execute for that method. These are called abstract methods. Here is an example of an abstract class.

<pre><code>class shape {
public:
 virtual void draw() = 0;
};
</code></pre>

This declares an abstract class which specifies that any descendants of the class should implement the draw method if the class is to be concrete. You cannot instantiate this class because it is abstract, after all, the compiler wouldn't know what code to execute if you called member draw. So you can not do the following:

<pre><code>shape my_shape();
my_shape.draw();
</code></pre>

To be able to actually use the draw method you would need to derive classes from this abstract class, which do implement the draw method, making the classes concrete:

<pre><code>class circle : public shape {
public:
 circle(int x, int y, int radius) {
 /* set up the circle */
 }
 virtual draw() {
 /* do stuff to draw the circle */
 }
};

class rectangle : public shape {
public:
 rectangle(int min_x, int min_y, int max_x, int max_y) {
 /* set up rectangle */
 }
 virtual draw() {
 /* do stuff to draw the rectangle */
 }
};
</code></pre>

Now you can instantiate the concrete objects circle and rectangle and use their draw methods:

<pre><code>circle my_circle(40, 30, 10);
rectangle my_rectangle(20, 10, 50, 15);
my_circle.draw();
my_rectangle.draw();
</code></pre>

Now of course the question is, why would you want to do this? Couldn't you just as well have defined the circle and rectangle classes and have done away with the whole shape class? You could, but then you wouldn't be able to take advantage of their inheritance:

<pre><code>std::vector&lt;shape*&gt; my_scene;
my_scene.push_back(new circle(40, 30, 10));
my_scene.push_back(new rectangle(20, 10, 50, 15));
std::for_each(my_scene.begin(), my_scene.end(), std::mem_fun_ref(&amp;shape::draw)
</code></pre>

This code let's you collect all your shapes into one container. This makes it a lot easier if you have a lot of shapes and many different shapes in your scene. For example we can now draw all the shapes in one go, and the code that does so doesn't even need to know about the different types of shapes we have.

Now finally we need to know why the draw function of shape is abstract, and not just an empty function, i.e. why didn't we just define:

<pre><code>class shape {
public:
 virtual void draw() {
 /* do nothing */
 }
};
</code></pre>

The reason for this is that we don't really want objects of type shape, they wouldn't be real things anyway, they would be abstract. So it doesn't make any sense to define an implementation for the draw method, even an empty one. Making the shape class abstract prevents us from mistakenly instantiating the shape class, or mistakenly calling the empty draw function of the base class instead of the draw function of the derived classes. In effect we define an interface for any class that would like to behave like a shape, we say that any such class should have a draw method that looks like we have specified it should.

To answer you last question, there isn't any such thing as a 'normal derived class' every class is either abstract or concrete. A class that has any abstract methods is abstract, any class that doesn't is concrete. It's just a way to differentiate the two types of classes. A base class can be either abstract or concrete and a derived class can be either abstract or concrete:

<pre><code>class abstract_base {
public:
 virtual void abstract_method1() = 0;
 virtual void abstract_method2() = 0;
};

class concrete_base {
public:
 void concrete_method1() {
 /* do something */
 }
};

class abstract_derived1 : public abstract_base {
public:
 virtual void abstract_method3() = 0;
};

class abstract_derived2 : public concrete_base {
public:
 virtual void abstract_method3() = 0;
};

class abstract_derived3 : public abstract_base {
public:
 virtual abstract_method1() {
 /* do something */
 }
 /* note that we do not provide an implementation for
 abstract_method2 so the class is still abstract */
};

class concrete_derived1 : public concrete_base {
public:
 void concrete_method2() {
 /* do something */
 }
};

class concrete_derived2 : public abstract_base {
public:
 virtual void abstract_method1() {
 /* do something */
 }
 virtual void abstract_method2() {
 /* do something */
 }
 /* This class is now concrete because no abstract methods remain */
};
</code></pre>

blocks|key|1131509|text|具体类实现了它的所有方法。抽象类的所有方法，除了一些(至少一个)未实现的方法，以便您可以扩展它并实现未实现的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1131510|优点:通过从抽象类扩展，你获得了基类的所有功能&你将“被迫”实现未实现的方法。因此，类的设计者基本上是在强迫您在类对您有用之前用抽象方法编写代码。|1131511|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Concrete class has all its method implemented. Abstract class all its method except some (at least one) method(s) un-implemented so that you can extend it and implement the un-implemented method. 

Advantage : By extending from abstract class you get all functionality of base class &amp; you will be 'forced' to implement the un-implemented method. So the designer of the class is basically forcing you to write code in the abstract method before the class is of any use to you.

I am learning C++, but I am confused about abstract class and concrete class. Some real world examples would be appreciated.

What is the difference between a concrete class and an abstract class?

数据存储

SQL数据库

数据库

编译器

容器

SQLite

MySQL

我正在学习C++，但我对抽象类和具体类感到困惑。一些现实世界的例子将会很受欢迎。

问具体类和抽象类之间的区别是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问具体类和抽象类之间的区别是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问具体类和抽象类之间的区别是什么？
EN