blocks|key|1132146|text|在C%2B%2B中，内置类型不是类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1132147|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In C++ the built-in types are not classes.

blocks|key|1132215|text|因为int是本机类型而不是类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1132216|编辑:将我的评论移动到我的答案中。|1132217|它来自于C语言的传统，以及原语所代表的东西。c%2B%2B中的原语只是一个字节的集合，除了对编译器之外，这些字节几乎没有意义。另一方面，一个类有一个函数表，一旦你开始沿着继承和虚拟继承的路径走下去，你就有了一个vtable。所有这些都不存在于原语中，通过使其存在，您将a)破坏大量假定int仅为8字节的c代码，以及b)使程序占用更多的内存。|1132218|换一种方式考虑一下。int/float/char没有任何数据成员或方法。把基本体想象成夸克--它们是你不能细分的积木，你用它们来制造更大的东西(抱歉，如果我的类比有点离谱，我对粒子物理学了解不够多)|1132219|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|$]]

Because int is a native type and not a class

Edit: moving my comments into my answer.

It comes from the C heritage and what, exactly, primitives represent. A primitive in c++ is just a collection of bytes that have little meaning except to the compiler. A class, on the other hand, has a function table, and once you start going down the inheritance and virtual inheritance path, then you have a vtable. None of that is present in a primitive, and by making it present you would a) break a lot of c code that assumes an int is 8 bytes only and b) make programs take up a lot more memory.

Think about it another way. int/float/char don't have any data members or methods. Think of the primitives as quarks - they're the building blocks that you can't subdivide, you use them to make bigger things (apologies if my analogy is a little off, I don't know enough particle physics)

blocks|key|1132273|text|从int继承是什么意思？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1132274|"int“没有成员函数；它没有成员数据，它是内存中的32+(或64)位表示。它没有自己的vtable。它所“拥有的”(它甚至不真正拥有它们)是一些像%2B-/*这样的运算符，它们实际上是比成员函数更多的全局函数。|1132275|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|$]]

What does it mean to inherit from an int?

"int" has no member functions; it has no member data, it's a 32 (or 64) bit representation in memory. It doesn't have it's own vtable. All what it "has" (it doesn't really even own them) are some operators like +-/* that are really more global functions than member functions.

blocks|key|1347719|text|别人说的都是真的..。int是C%2B%2B中的原语(与C#非常相似)。但是，只需围绕int构建一个类，就可以实现您想要的功能|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1347720|class+MyInt
{
private:
+++int+mInt;

public:
+++explicit+MyInt(int+in)+{+mInt+=+in;+}
+++//+Getters/setters+etc
};|code-block|syntax|javascript|1347721|然后你可以继承所有你想要的东西。|1347722|entityMap^0|B|3|13|3|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

What others have said is true... <code>int</code> is a primitive in C++ (much like C#). However, you can achieve what you wanted by just building a class around <code>int</code>:

<pre><code>class MyInt
{
private:
 int mInt;

public:
 explicit MyInt(int in) { mInt = in; }
 // Getters/setters etc
};
</code></pre>

You can then inherit from that all you jolly want.

blocks|key|1347737|text|如果我没记错的话，这是C%2B%2B不被认为是真正的面向对象语言的主要原因之一。Java人会说：“在Java中，一切都是对象”;)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1347738|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If I remember, this was the main - or one of - the main reasons C++ was not considered a true object oriented language. Java people would say: "In Java, EVERYTHING is an object" ;)

blocks|key|1132366|text|这与项目在内存中的存储方式有关。正如在其他地方提到的，C%2B%2B中的整型是一个整型，在内存中只有32或64位(一个字)。然而，对象在内存中的存储方式是不同的。它通常存储在堆上，并且具有与多态性相关的功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1132367|我不知道怎样才能解释得更好。你将如何从数字4继承？|1132368|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|$]]

This is related to how the items are stored in memory. An int in C++ is an integral type, as mentioned elsewhere, and is just 32 or 64 bits (a word) in memory. An object, however, is stored differently in memory. It is usually stored on the heap, and it has functionality related to polymorphism.

I don't know how to explain it any better. How would you inherit from the number 4?

blocks|key|1132394|text|正如其他人所说，不能这样做，因为int是一个原始类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1132395|不过，如果是为了更强的输入，我理解其中的动机。甚至有人建议C%2B%2B0x应该有一个special+kind+of+typedef就足够了(但是这个建议已经被拒绝了？)|offset|length|1132396|如果您自己提供基本包装器，也许可以实现一些目标。例如，如下所示，它希望以合法的方式使用奇怪的递归模板，并且只需要派生一个类并提供一个合适的构造函数：|1132397|template+<class+Child,+class+T>
class+Wrapper
{
++++T+n;
public:
++++Wrapper(T+n+=+T()):+n(n)+{}
++++T&+value()+{+return+n;+}
++++T+value()+const+{+return+n;+}
++++Child+operator%2B=+(Wrapper+other)+{+return+Child(n+%2B=+other.n);+}
++++//...+many+other+operators
};

template+<class+Child,+class+T>
Child+operator%2B(Wrapper<Child,+T>+lhv,+Wrapper<Child,+T>+rhv)
{
++++return+Wrapper<Child,+T>(lhv)+%2B=+rhv;
}

//Make+two+different+kinds+of+"int"'s

struct+IntA+:+public+Wrapper<IntA,+int>
{
++++IntA(int+n+=+0):+Wrapper<IntA,+int>(n)+{}
};

struct+IntB+:+public+Wrapper<IntB,+int>
{
++++IntB(int+n+=+0):+Wrapper<IntB,+int>(n)+{}
};

#include+<iostream>

int+main()
{
++++IntA+a1+=+1,+a2+=+2,+a3;
++++IntB+b1+=+1,+b2+=+2,+b3;
++++a3+=+a1+%2B+a2;
++++b3+=+b1+%2B+b2;
++++//a1+%2B+b1;++//bingo
++++//a1+=+b1;+//bingo
++++a1+%2B=+a2;

++++std::cout+<<+a1.value()+<<+'+'+<<+b3.value()+<<+'\n';
}|code-block|syntax|javascript|1132398|但是，如果您接受了只应该定义一个新类型并重载操作符的建议，那么您可能会考虑一下Boost.Operators|1132399|entityMap|0|LINK|mutability|MUTABLE|url|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1891.pdf|1|http://www.boost.org/doc/libs/1_39_0/libs/utility/operators.htm^0|0|13|N|0|0|0|0|13|F|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@$D|16|E|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

As others I saying, can't be done since int is a primitive type.

I understand the motivation, though, if it is for stronger typing. It has even been proposed for C++0x that a <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1891.pdf" rel="nofollow noreferrer">special kind of typedef</a> should be enough for that (but this has been rejected?).

Perhaps something could be achieved, if you provided the base wrapper yourself. E.g something like the following, which hopefully uses curiously recurring templates in a legal manner, and requires only deriving a class and providing a suitable constructor:

<pre><code>template &lt;class Child, class T&gt;
class Wrapper
{
 T n;
public:
 Wrapper(T n = T()): n(n) {}
 T&amp; value() { return n; }
 T value() const { return n; }
 Child operator+= (Wrapper other) { return Child(n += other.n); }
 //... many other operators
};

template &lt;class Child, class T&gt;
Child operator+(Wrapper&lt;Child, T&gt; lhv, Wrapper&lt;Child, T&gt; rhv)
{
 return Wrapper&lt;Child, T&gt;(lhv) += rhv;
}

//Make two different kinds of "int"'s

struct IntA : public Wrapper&lt;IntA, int&gt;
{
 IntA(int n = 0): Wrapper&lt;IntA, int&gt;(n) {}
};

struct IntB : public Wrapper&lt;IntB, int&gt;
{
 IntB(int n = 0): Wrapper&lt;IntB, int&gt;(n) {}
};

#include &lt;iostream&gt;

int main()
{
 IntA a1 = 1, a2 = 2, a3;
 IntB b1 = 1, b2 = 2, b3;
 a3 = a1 + a2;
 b3 = b1 + b2;
 //a1 + b1; //bingo
 //a1 = b1; //bingo
 a1 += a2;

 std::cout &lt;&lt; a1.value() &lt;&lt; ' ' &lt;&lt; b3.value() &lt;&lt; '\n';
}
</code></pre>

But if you take the advice that you should just define a new type and overload the operators, you might take a look at <a href="http://www.boost.org/doc/libs/1_39_0/libs/utility/operators.htm" rel="nofollow noreferrer">Boost.Operators</a>

blocks|key|1348045|text|为什么你不能从int继承，即使你想这样做呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1348046|性能|1348047|你不能(在任意语言中)从顺序类型继承(如int、char或char*等)没有任何功能上的原因。一些语言，如Java和Objective-C实际上提供了基类型的类/对象(盒式)版本，以满足这一需求(以及处理顺序类型不是对象的一些其他令人不快的后果)：|1348048|language+++++ordinal+type+boxed+type,+
c%2B%2B++++++++++int++++++++++?
java+++++++++int++++++++++Integer
objective-c++int++++++++++NSNumber|code-block|syntax|javascript|1348049|但即使是Java和objective-c也保留了它们的序数类型以供使用……为什么？|1348050|原因很简单，就是性能和内存消耗。序数类型通常可以在一条或两条X86指令中按值构造、操作和传递，并且在最坏的情况下只消耗几个字节。一个类通常不能-它通常使用2倍或更多的内存，并且操作它的值可能需要数百个周期。|1348051|这意味着理解这一点的程序员通常会使用序数类型来实现对性能或内存使用敏感的代码，并要求语言开发人员支持基类型。|1348052|应该注意的是，相当多的语言没有序数类型，特别是像perl这样的动态语言，它几乎完全依赖于可变类型，这完全是另一回事，并分担了一些类的开销。|offset|length|style|CODE|1348053|entityMap^0|0|0|0|0|0|0|0|O|4|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@$S|16|T|17|U|V]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Why can't you inherit from int, even though you might want to?

<h2>Performance</h2>

There's no functional reason why you shouldn't be able (in an arbitrary language) inherit from ordinal types such as int, or char, or char* etc. Some languages such as Java and Objective-C actually provide class/object (boxed) versions of the base type, in order to satisfy this need (as well as to deal with some other unpleasant consequences of ordinal types not being objects):

<pre><code>language ordinal type boxed type, 
c++ int ?
java int Integer
objective-c int NSNumber
</code></pre>

But even Java and objective-c preserve their ordinal types for use... why?

The simple reasons are performance and memory consumption. An ordinal type can be typically be constructed, operated upon, and passed by value in just one or two X86 instructions, and only consumes a few bytes at worst. A class typically cannot - it often uses 2x or more as much memory, and manipulating its value may take many hundreds of cycles.

This means programmers who understand this will typically use the ordinal types to implement performance or memory usage sensitive code, and will demand that language developers support the base types.

It should be noted that quite a few languages do not have ordinal types, in particular the dynamic languages such as <code>perl</code>, which relies almost entirely on a variadic type, which is something else altogether, and shares some of the overhead of classes.

blocks|key|1348131|text|没有人提到过C%2B%2B被设计成(主要)与C语言向后兼容，以方便C程序员的升级路径，因此struct默认对所有成员公开等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1348132|将int作为您可以覆盖的基类将从根本上使该规则变得复杂，而且会使编译器实现变得糟糕透顶，如果您希望现有的编码器和编译器供应商支持您的初学语言，这可能是不值得的。|1348133|entityMap^0|15|6|0|1|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

No one has mentioned that C++ was designed to have (mostly) backwards compatibility with C, so as to ease the upgrade path for C coders hence <code>struct</code> defaulting to all members public etc.

Having <code>int</code> as a base class that you could override would fundamentally complicate that rule no end and make the compiler implementation hellish which if you want existing coders and compiler vendors to support your fledgling language was probably not worth the effort.

blocks|key|1348144|text|你可以通过强typedefs得到你想要的东西。请参阅BOOST_STRONG_TYPEDEF|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1348145|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_46_1/libs/serialization/doc/strong_typedef.html^0|Q|K|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You can get what you want with strong typedefs. See <a href="http://www.boost.org/doc/libs/1_46_1/libs/serialization/doc/strong_typedef.html" rel="nofollow noreferrer">BOOST_STRONG_TYPEDEF</a>

blocks|key|1348225|text|此答案是UncleBens答案的实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1348226|放入Primitive.hpp|1348227|#pragma+once

template<typename+T,+typename+Child>
class+Primitive+{
protected:
++++T+value;

public:

++++//+we+must+type+cast+to+child+to+so
++++//+a+%2B=+3+%2B=+5+...+and+etc..+work+the+same+way
++++//+as+on+primitives
++++Child+&childRef(){
++++++++return+*((Child*)this);
++++}

++++//+you+can+overload+to+give+a+default+value+if+you+want
++++Primitive(){}
++++explicit+Primitive(T+v):value(v){}

++++T+get(){
++++++++return+value;
++++}

++++#define+OP(op)+Child+&operator+op(Child+const+&v){\
++++++++value+op+v.value;+\
++++++++return+childRef();+\
++++}

++++//+all+with+equals
++++OP(%2B=)
++++OP(-=)
++++OP(*=)
++++OP(/=)
++++OP(<<=)
++++OP(>>=)
++++OP(%7C=)
++++OP(%5E=)
++++OP(&=)
++++OP(%25=)

++++#undef+OP

++++#define+OP(p)+Child+operator+p(Child+const+&v){\
++++++++Child+other+=+childRef();\
++++++++other+p+##+=+v;\
++++++++return+other;\
++++}

++++OP(%2B)
++++OP(-)
++++OP(*)
++++OP(/)
++++OP(<<)
++++OP(>>)
++++OP(%7C)
++++OP(%5E)
++++OP(&)
++++OP(%25)

++++#undef+OP


++++#define+OP(p)+bool+operator+p(Child+const+&v){\
++++++++return+value+p+v.value;\
++++}

++++OP(&&)
++++OP(%7C%7C)
++++OP(<)
++++OP(<=)
++++OP(>)
++++OP(>=)
++++OP(==)
++++OP(!=)

++++#undef+OP

++++Child+operator+%2B(){return+Child(value);}
++++Child+operator+-(){return+Child(-value);}
++++Child+&operator+%2B%2B(){%2B%2Bvalue;+return+childRef();}
++++Child+operator+%2B%2B(int){
++++++++Child+ret(value);
++++++++%2B%2Bvalue;
++++++++return+childRef();
++++}
++++Child+operator+--(int){
++++++++Child+ret(value);
++++++++--value;
++++++++return+childRef();
++++}

++++bool+operator!(){return+!value;}
++++Child+operator~(){return+Child(~value);}

};|code-block|syntax|javascript|1348228|示例：|1348229|#include+"Primitive.hpp"
#include+<iostream>

using+namespace+std;
class+Integer+:+public+Primitive<int,+Integer>+{
public:
++++Integer(){}
++++Integer(int+a):Primitive<int,+Integer>(a)+{}

};
int+main(){
++++Integer+a(3);
++++Integer+b(8);

++++a+%2B=+b;
++++cout+<<+a.get()+<<+"\n";
++++Integer+c;

++++c+=+a+%2B+b;
++++cout+<<+c.get()+<<+"\n";

++++cout+<<+(a+>+b)+<<+"\n";
++++cout+<<+(!b)+<<+"+"+<<+(!!b)+<<+"\n";

}|1348230|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This answer is an implementation of UncleBens answer

put in Primitive.hpp

<pre><code>#pragma once

template&lt;typename T, typename Child&gt;
class Primitive {
protected:
 T value;

public:

 // we must type cast to child to so
 // a += 3 += 5 ... and etc.. work the same way
 // as on primitives
 Child &amp;childRef(){
 return *((Child*)this);
 }

 // you can overload to give a default value if you want
 Primitive(){}
 explicit Primitive(T v):value(v){}

 T get(){
 return value;
 }

 #define OP(op) Child &amp;operator op(Child const &amp;v){\
 value op v.value; \
 return childRef(); \
 }

 // all with equals
 OP(+=)
 OP(-=)
 OP(*=)
 OP(/=)
 OP(&lt;&lt;=)
 OP(&gt;&gt;=)
 OP(|=)
 OP(^=)
 OP(&amp;=)
 OP(%=)

 #undef OP

 #define OP(p) Child operator p(Child const &amp;v){\
 Child other = childRef();\
 other p ## = v;\
 return other;\
 }

 OP(+)
 OP(-)
 OP(*)
 OP(/)
 OP(&lt;&lt;)
 OP(&gt;&gt;)
 OP(|)
 OP(^)
 OP(&amp;)
 OP(%)

 #undef OP


 #define OP(p) bool operator p(Child const &amp;v){\
 return value p v.value;\
 }

 OP(&amp;&amp;)
 OP(||)
 OP(&lt;)
 OP(&lt;=)
 OP(&gt;)
 OP(&gt;=)
 OP(==)
 OP(!=)

 #undef OP

 Child operator +(){return Child(value);}
 Child operator -(){return Child(-value);}
 Child &amp;operator ++(){++value; return childRef();}
 Child operator ++(int){
 Child ret(value);
 ++value;
 return childRef();
 }
 Child operator --(int){
 Child ret(value);
 --value;
 return childRef();
 }

 bool operator!(){return !value;}
 Child operator~(){return Child(~value);}

};
</code></pre>

Example:

<pre><code>#include "Primitive.hpp"
#include &lt;iostream&gt;

using namespace std;
class Integer : public Primitive&lt;int, Integer&gt; {
public:
 Integer(){}
 Integer(int a):Primitive&lt;int, Integer&gt;(a) {}

};
int main(){
 Integer a(3);
 Integer b(8);

 a += b;
 cout &lt;&lt; a.get() &lt;&lt; "\n";
 Integer c;

 c = a + b;
 cout &lt;&lt; c.get() &lt;&lt; "\n";

 cout &lt;&lt; (a &gt; b) &lt;&lt; "\n";
 cout &lt;&lt; (!b) &lt;&lt; " " &lt;&lt; (!!b) &lt;&lt; "\n";

}
</code></pre>

blocks|key|1348287|text|请原谅，我的英语很差。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1348288|C%2B%2B正确构造之间有一个主要区别，如下所示：|1348289|struct+Length+{+double+l;+operator+=!?:%25%2B-*/...();+};
struct+Mass+{+double+l;+operator+=!?:%25%2B-*/...();+};|code-block|syntax|javascript|1348290|和拟议的扩展|1348291|struct+Length+:+public+double+;
struct+Mass+++:+public+double+;|1348292|这种不同之处在于关键字this行为。this是一个指针，使用指针可以减少使用寄存器进行计算的机会，因为在通常的处理器中，寄存器没有地址。最糟糕的是，使用指针会使编译器怀疑两个指针可能指定相同的内存。|offset|length|style|CODE|1348293|这将给编译器带来额外的负担来优化琐碎的操作。|1348294|另一个问题是bug的数量:准确地再现操作符的所有行为绝对容易出错(因为ex显式构造函数并不禁止所有隐含的情况)。在构建这样的对象时出错的概率相当高。这并不等同于有可能通过艰苦的工作来做某事，或者已经做完了。|1348295|编译器实现者会引入类型检查代码(可能有一些错误，但编译器的准确性比客户端代码好得多，因为编译器中的任何错误都会产生无数的错误情况)，但操作的主要行为将保持不变，错误比平时少得多。|1348296|建议的替代解决方案(在调试阶段使用结构，在优化时使用实型浮点)很有趣，但也有缺点:它增加了只有在优化版本中才有bug的可能性。并且调试优化的应用程序是非常昂贵的。|1348297|对于整数类型的@Rocketmagnet初始需求，可以使用以下方法来实现一个很好的建议：|1348298|enum+class+MyIntA+:+long+{};+
auto+operator=!?:%25%2B-*/...(MyIntA);
MyIntA+operator+""+_A(long);|1348299|bug级别会很高，就像使用单成员技巧一样，但编译器会像对待内置整数一样对待这些类型(包括寄存器功能和优化)，这要归功于内联。|1348300|但这个技巧不能(遗憾地)用于浮点数，而最好的需求显然是实值维度检查。不能把苹果和梨混在一起:增加长度和面积是一个常见的错误。|1348301|@Jerry对Stroustrup的调用无关紧要。虚拟性主要是对公共继承有意义的，这里需要的是私有继承。考虑“混乱”的C转换规则(+C%2B%2B14有没有不混乱的东西？)基本类型的转换也没有用:目标是没有默认的转换规则，而不是遵循标准的转换规则。|1348302|entityMap^0|0|0|0|0|0|B|4|I|4|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1H|8|@$O|1I|P|1J|Q|R]|$O|1K|P|1L|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1P|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|F|7|1R|8|@]|9|@]|A|$G|H]]|$1|14|3|15|5|6|7|1S|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|1T|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|1U|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|1B|$]]

Please, excuse me for my poor English.

There is a major difference between C++ correct construction like this:

<pre><code>struct Length { double l; operator =!?:%+-*/...(); };
struct Mass { double l; operator =!?:%+-*/...(); };
</code></pre>

and the proposed extension 

<pre><code>struct Length : public double ;
struct Mass : public double ;
</code></pre>

And this difference lies on the keyword <code>this</code> behavior. <code>this</code> is a pointer and using a pointer let few chances to use registers for computations, because in usuals processors registers does not have address. Worst, using pointer make the compiler suspicous about the fact that two pointers may designate the same memory.

This will put an extraordinary burden on the compiler to optimize trivials ops. 

Another problem is on the number of bugs: reproducing exactly all the behavior of operators is absolutly error prone (for ex making constructor explicit does not forbid all implicits cases). Probability of error while building such an object is quite high. It is not equivalent to have the possibility to do something thru hard work or to have it already done. 

Compiler implementors would introduce type checking code (with maybe some errors, but compiler exactness is much better than client code, because of any bug in compiler generate countless errors cases), but main behavior of operation will remain exactly the same, with as few errors than usual.

The proposed alternate solution (using structs during debug phase and real floats when optimized ones) is interesting but has drawbacks: it's raise the probability to have bugs only in optimized version. And debugging optimized application is much costly.

One may implement a good proposal for @Rocketmagnet initial demand for integers types using :

<pre><code>enum class MyIntA : long {}; 
auto operator=!?:%+-*/...(MyIntA);
MyIntA operator "" _A(long);
</code></pre>

The bug level will be quite high, like using single member trick, but compiler will treat thoses types exactly like built-in integers (including register capability &amp; optimisation), thanks for inlining.

But this trick can't be used (sadly) for floating numbers, and the nicest need is obviously real valued dimensions checking. One may not mix up apples and pears: adding length and area is a common error.

Stroustrup' invocation by @Jerry is irrelevant. Virtuality is meaningful mainly for public inheritance, and the need is here toward private inheritance. Consideration around 'chaotic' C conversion rules (Does C++14 have anything not chaotic?) of basic type are also not useful : the objective is to have no default conversion rules, not to follow standard ones.

blocks|key|1348363|text|这是一个非常古老的话题，但仍然与许多人相关。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1348364|单元感知编程提供了一个非常重要的原因，为什么从内部/基础类型继承在C%2B%2B中很有价值。现在有许多开发良好的解决方案来解决这个问题，但所有这些解决方案都需要模板，以便实现原本可以通过继承、多态性和强大的C%2B%2B类型检查直接处理的功能。以下是单元感知编程的一种替代方案：|1348365|https://benjaminjurke.com/content/articles/2015/compile-time-numerical-unit-dimension-checking/|offset|length|1348366|从原始指针继承也是有意义的(而且也是非法的)。我们可以很容易地创建一个从智能指针继承的类，从而扩展它的行为，但由于C%2B%2B的限制，我们无法对原始指针做同样的事情。这意味着我们扩展原始指针(如char*+)行为的唯一方法是编写需要将指针作为参数传递给函数的函数，而不是使它们看起来更像您可能在std::string中看到的方法。|1348367|当然，我们总是可以使用组合而不是继承来获得相同的效果，但在这样做的过程中，我们会丢失所有的内部操作(例如字符*的operator[]和operator%2B%2B+)，并且必须重新映射我们需要支持的每一个操作。这是可行的吗？好的。我已经做到了。这很容易吗？不一定。这取决于你需要映射多少以及需要多快完成。速度快吗？视情况而定。|1348368|尽管如此，在我看来，支持从内部类型(包括原始指针类型)继承行为的最大论点是它证明了语言在概念上的一致性。总体而言，C%2B%2B是非常一致的，但在我的书中，它被分解了一点，因为内部类型被认为是特殊的，坦率地说，它们并不特殊。|1348369|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2N|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@$F|X|G|Y|1|Z]]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|E]]]]

This is a very old topic, but still relevant to many.
Unit-aware programming provides one very important reason why inheriting from intrinsic/fundamental types would be valuable in C++. Numerous well-developed solutions now exist to this problem, but all of them require templates in order to achieve what might otherwise have been handled directly with inheritance, polymorphism, and the strong type-checking of C++. The following is one such alternative for unit-aware programming:
<a href="https://benjaminjurke.com/content/articles/2015/compile-time-numerical-unit-dimension-checking/" rel="nofollow noreferrer">https://benjaminjurke.com/content/articles/2015/compile-time-numerical-unit-dimension-checking/</a>
Inheriting from raw pointers also makes sense (and is also illegal). We can easily create a class where we inherit from a smart pointer thereby extending its behavior, but due to the limitation of C++, we are unable to do the same with a raw pointer. This means that our only way to extend behavior of raw pointers like char* is to write functions that require the pointer to be passed as an argument to the function instead of making them look more like methods you might see within std::string.
Of course, we can always use composition instead of inheritance to get the same effect, but in so-doing, we lose all of the intrinsic operations (such as operator[] and operator++ for a char*) and must remap every one of them that we need to support. Is it doable? Sure. I've done it. Is it easy? Not necessarily. That depends on how much you need to map and how quickly it needs to get done. Is it fast? Depends.
With all of that said, in my view, the biggest argument in favor of inheriting behavior from intrinsic types (including raw pointer types) is that it demonstrates the conceptual consistency of the language. Overall, C++ is very consistent, but it breaks down a bit here in my book as intrinsic types are considered to be special, and frankly, they are not.

I'd love to be able to do this:

<pre><code>class myInt : public int
{

};
</code></pre>

Why can't I?

Why would I want to? Stronger typing. For example, I could define two classes <code>intA</code> and <code>intB</code>, which let me do <code>intA + intA</code> or <code>intB + intB</code>, but not <code>intA + intB</code>.

"Ints aren't classes." So what?

"Ints don't have any member data." Yes they do, they have 32 bits, or whatever.

"Ints don't have any member functions." Well, they have a whole bunch of operators like <code>+</code> and <code>-</code>.

Why can't I inherit from int in C++?

我希望能够做到这一点：class myInt : public int{};为什么不行？我为什么要这么做呢？更强的类型。例如，我可以定义两个类intA和intB，这两个类允许我执行intA + intA或intB + intB，但不能执行intA + intB。“Int不是类。”那又怎么样？"Ints没有任何成员数据。...

问为什么我不能在C++中从int继承？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能在C++中从int继承？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能在C++中从int继承？
EN