blocks|key|1586043|text|如果您自己没有做任何事情来控制对象的创建，则会添加默认的无参数构造函数。一旦你创建了一个单独的构造函数来获得控制权，编译器就会“后退”，让你拥有完全的控制权。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1586044|如果不是这样的话，如果你只想通过一个带参数的构造函数来构造对象，那么你就需要一些明确的方法来禁用默认的构造函数。|1586045|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|$]]

The default, parameterless constructor is added if you don't do anything yourself to take control over object creation. Once you've created a single constructor to take control, the compiler "backs off" and let you have the full control.

If it wouldn't be this way, you would need some explicit way of disabling the default constructor if you only want objects to be constructable through a constructor with parameters.

blocks|key|1801058|text|我认为问题应该是相反的:如果你没有定义任何其他构造函数，为什么不需要声明一个默认构造函数呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1801059|构造函数对于非静态类是必需的。|1801060|所以我认为，如果您没有定义任何构造函数，那么生成的默认构造函数只是C#编译器的一个方便特性，而且如果没有构造函数，您的类将不会有效。所以，隐式生成一个什么也不做的构造函数并没有错。它看起来当然比到处都是空的构造函数看起来更干净。|1801061|如果你已经定义了一个构造函数，那么你的类是有效的，那么为什么编译器要假设你想要一个默认的构造函数呢？如果你不想要呢？实现一个属性来告诉编译器不要生成那个默认的构造函数？我不认为这是个好主意。|1801062|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|$]]

I think the question should be the other way around: Why don't you need to declare a default constructor if you haven't defined any other constructors? 

A constructor is mandatory for non-static classes. 
So i think if you haven't defined any constructors, the generated default constructor is just a convenient feature of the C# compiler, also your class wouldn't be valid without a constructor. So nothing wrong with implicitly generating a constructor that does nothing. It certainly looks cleaner than having empty constructors all around. 

If you have already defined a constructor, your class is valid, so why should the compiler assume you want a default constructor? What if you don't want one? Implement an attribute to tell the compiler to not generate that default constructor? I don't think that would be a good idea.

blocks|key|1801234|text|这是编译器的一个方便函数。如果您定义了一个带参数的构造函数，但没有定义一个无参数的构造函数，那么您不想允许无参数的构造函数的可能性要高得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1801235|对于许多对象来说，使用空的构造函数进行初始化是没有意义的。|1801236|否则，您必须为您想要限制的每个类声明一个私有的无参数构造函数。|1801237|在我看来，对于需要参数才能运行的类，允许无参数构造函数是不好的风格。|1801238|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|$]]

It's a convenience function of the compiler.
If you define a Constructor with parameters but don't define a parameterless constructor, the possibility that you don't want to allow a parameterless constructor is much higher.

This is the case for many objects that just don't make sense to initialize with an empty constructor.

Otherwise you'd have to declare a private parameterless constructor for each class that you want to restrict.

In my opinion it's not good style to allow a parameterless constructor for a class that needs parameters to function.

blocks|key|1801471|text|编辑。实际上，虽然我在第一个答案中说的是正确的，但这才是真正的原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1801472|在开始的时候，C语言不是面向对象的(你可以采用面向对象的方法，但它不能帮助你，也不能强制执行任何东西)。|1801473|C%2B%2B是面向对象的，因此鼓励封装，并确保对象的不变性-在构造和任何方法的开始和结束时，对象都处于有效状态。|1801474|1801475|但C%2B%2B的一个目标是与C语言兼容，尽可能多地，所有有效的C程序也是有效的C%2B%2B程序(目标不再是活动的，而C语言独立于C%2B%2B的演变意味着它不再有效)。|1801476|前者用C语言做事情(默认情况下所有东西都是公开的)，后者用好的OO方式做事情(默认情况下所有东西都是私有的，开发人员主动地公开他们想公开的东西)。|1801477|另一个原因是，为了让C的struct在C%2B%2B中有效，它不能有构造函数，因为C没有构造函数，所以必须用C%2B%2B的方式来看待它。因此，虽然没有构造函数会与积极确保不变量的OO实践背道而驰，但C%2B%2B认为这意味着有一个默认的无参数构造函数，它的行为就像是有一个空的主体。|offset|length|style|CODE|1801478|1801479|但是，如果您确实在class或struct中放置了构造函数，那么您将使用C%2B%2B/OO方式而不是C方式，并且不需要默认构造函数。|1801480|由于它是一种速记，所以即使在兼容性不可能的情况下，人们也会继续使用它(它使用了其他不是C语言的C%2B%2B特性)。|1801481|1801482|斯特劳斯特鲁普在他的《C%2B%2B编程语言》一书中写到了这一点，甚至更多地关注了C%2B%2B设计和发展中语言的“为什么”。|1801483|===原始答案===|1801484|让我们假设这并没有发生。|1801485|比方说，我不想要无参数构造函数，因为如果没有参数构造函数，我就不能将类置于有意义的状态。实际上，这是在C#中使用struct时可能发生的事情(但是如果您不能在C#中有效地使用全零和空值的struct，那么您充其量只能使用一个非公开可见的优化，否则在使用struct时就会有一个设计缺陷)。|1801486|至少，我需要创建一个私有的无参数构造函数，以确保调用代码不会调用默认值。|1801487|这使语言变得更加复杂。最好不要这样做。|1801488|总而言之，最好不要认为添加构造函数就是删除默认构造函数，最好将根本没有构造函数看作是添加一个不做任何事情的无参数构造函数的语法糖。|1801489|entityMap^0|0|0|0|0|0|0|C|6|0|0|9|5|F|6|0|0|0|0|0|0|1K|6|2L|6|3I|6|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|6|7|1E|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1G|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1H|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1I|8|@$M|1J|N|1K|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1M|8|@$M|1N|N|1O|O|P]|$M|1P|N|1Q|O|P]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1R|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1T|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1U|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1V|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1W|8|@$M|1X|N|1Y|O|P]|$M|1Z|N|20|O|P]|$M|21|N|22|O|P]]|9|@]|A|$]]|$1|14|3|15|5|6|7|23|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|24|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|25|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|26|8|@]|9|@]|A|$]]]|1B|$]]

Edit. Actually, while what I say in my first answer is valid, this is the real reason.:

In the beginning there was C. C is not object-oriented (you can take an OO approach, but it doesn't help you or enforce anything).

Then there was C With Classes, that was later renamed C++. C++ is object-oriented, and therefore encourages encapsulation, and ensuring an object's invariant - upon construction and at the beginning and end of any method, the object is in a valid state.

The natural thing to do with this, is to enforce that a class must always have a constructor to ensure it starts in a valid state - if the constructor doesn't have to do anything to ensure this, then the empty constructor will document this fact.

But a goal with C++ was to be compatible with C to the point that as much as possible, all valid C programs were also valid C++ programs (no longer as active a goal, and the evolution of C separate to C++ means it no longer holds).

One effect of this was the duplication in functionality between <code>struct</code> and <code>class</code>. The former doing things the C way (everything public by default) and the latter doing things in a good OO way (everything private by default, developer actively makes public what they want public).

Another is that in order for a C <code>struct</code>, which couldn't have a constructor because C doesn't have constructors, to be valid in C++, then there had to be a meaning for this to the C++ way of looking at it. And so, while not having a constructor would go against the OO practice of actively ensuring an invariant, C++ took this to mean that there was a default parameterless constructor that acted like it had an empty body.

All C <code>structs</code> were now valid C++ <code>structs</code>, (which meant they were the same as C++ <code>classes</code> with everything - members and inheritance - public) treated from the outside as if it had a single, parameterless constructor.

If however you did put a constructor in a <code>class</code> or <code>struct</code>, then you were doing things the C++/OO way rather than the C way, and there was no need for a default constructor.

Since it served as a shorthand, people kept using it even when compatibility wasn't possible otherwise (it used other C++ features not in C).

Hence when Java came along (based on C++ in many ways) and later C# (based on C++ and Java in different ways), they kept this approach as something coders may already be used to.

Stroustrup writes about this in his The C++ Programming Language and even more so, with more focus upon the "whys" of the language in The Design and Evolution of C++.

=== Original Answer ===

Let's say this didn't happen.

Let's say I don't want a parameterless constructor, because I can't put my class into a meaningful state without one. Indeed, this is something that can happen with <code>struct</code> in C# (but if you can't make meaningful use of an all-zeros-and-nulls <code>struct</code> in C# you're at best using a non-publicly-visible optimisation, and otherwise have a design flaw in using <code>struct</code>).

To make my class able to protect its invariants, I need a special <code>removeDefaultConstructor</code> keyword. At the very least, I'd need to create a private parameterless constructor to make sure no calling code calls the default.

Which complicates the language some more. Better not to do it.

In all, it's best not to think of adding a constructor as removing the default, better to think of having no constructor at all as syntactic sugar for adding a parameterless constructor that doesn't do anything.

blocks|key|1587017|text|只有当类没有构造函数时，才能构造默认构造函数。编译器以这样一种方式编写，即只将其作为备份机制。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1587018|如果您有参数化的构造函数，则可能不希望使用默认构造函数创建对象。如果编译器提供了默认的构造函数，您就必须编写一个无参数的构造函数并将其设置为私有，以防止使用不带参数的对象创建对象。|1587019|此外，您可能会忘记禁用或“私有化”默认构造函数，从而导致难以捕获的潜在功能错误的可能性更高。|1587020|现在，如果您希望以默认方式或通过传递参数来创建对象，则必须显式定义一个无参数构造函数。这是经过严格检查的，否则编译器会报错，从而确保这里没有漏洞。|1587021|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|$]]

The default constructor can be constructed only when the class doesn't have a constructor. Compilers are written in such a way as to provide this only as a backup mechanism.

If you have a parameterized constructor, you may not want an object to be created using the default constructor. Had the compiler provided a default constructor, you would have had to write a no-arg constructor and make it private in order to prevent objects being created using no arguments.

Also, there would be higher chances of you forgetting disabling, or 'privatising' the default constructor, and thereby causing a potential functional error hard to catch.

And now you have to explicitly define a no-arg constructor if you'd like an object to be created either the default way or by passing parameters. This is strongly checked, and the compiler complains otherwise, thereby ensuring no loophole here.

blocks|key|1587114|text|这是因为当您没有定义构造函数时，编译器会自动为您生成一个不带任何参数的构造函数。当你想从一个构造器中得到更多的东西时，你可以重写它。这不是函数重载。所以编译器现在看到的唯一的构造函数是你的构造函数，它接受一个参数。要解决此问题，可以在构造函数传递时没有值的情况下传递默认值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1587115|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|$]]

Its because when you do not define a constructor the compiler automatically generates a constructor for you which does not take any arguments. When you want something more out of a constructor, you over-ride it. This is NOT function overloading. So the only constructor that the compiler sees now is your constructor which takes an argument. To counter this problem you can pass a default value if the constructor is passed with no value.

blocks|key|1801721|text|我认为这是由编译器处理的。如果您在ILDASM中打开.net程序集，您将看到默认构造函数，即使它不在代码中。如果定义参数化构造函数，则看不到默认构造函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1801722|实际上，当您定义类(非静态)时，编译器会提供此功能，并认为您将只创建一个实例。如果你想要执行任何特定的操作，你肯定会有自己的构造函数。|1801723|entityMap^0|H|6|Q|4|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

I think this is handled by the compiler. If you open the <code>.net</code> assembly in <code>ILDASM</code> you will see the default constructor, even if it is not in the code. If you define a parameterized constructor the default constructor will not bee seen. 

Actually when you define the class (non static), the compiler provides this feature thinking that you will be just creating an instance. And if you want any specific operation to perform you surely will be having your own constructor.

In C#, C++ and Java, when you create a constructor taking parameters, the default parameterless one goes away. I have always just accepted this fact, but now I've started wondering why.

What is the reason for this behavior? Is it just a "safety measure/guess" saying "If you've created a constructor of your own, you probably don't want this implicit one hanging around"?
Or does it have a technical reason that makes it impossible for the compiler to add one once you have created a constructor yourself?

Why does the default parameterless constructor go away when you create one with parameters

编译器

Java

在C#、C++和Java中，当你创建一个带参数的构造函数时，默认的无参数构造函数就消失了。我一直都在接受这个事实，但现在我开始想知道为什么。出现这种行为的原因是什么？这只是一种“安全措施/猜测”的说法吗？“如果你已经创建了自己的构造函数，你可能不想让这个隐式的构造函数出现”？

问为什么在创建带有参数的构造函数时，默认的无参数构造函数会消失
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在创建带有参数的构造函数时，默认的无参数构造函数会消失EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在创建带有参数的构造函数时，默认的无参数构造函数会消失
EN