C++ 一个类有多少个默认方法？

How Many default methods does a class have?

提问by Armen Tsirunyan

Sorry, this might seem simple, but somebody asked me this, and I don't know for certain.

抱歉，这可能看起来很简单，但有人问过我这个问题，我不确定。

An empty C++ class comes with what functions?

一个空的 C++ 类带有什么功能？

Constructor, Copy Constructor, Assignment, Destructor?

构造函数、复制构造函数、赋值、析构函数？

Is that it? Or are there more?

是这样吗？或者还有更多？

回答by Armen Tsirunyan

In C++03 there are 4:

在 C++03 中有 4 个：

• Default constructor: Declared only if no user-defined constructor is declared. Defined when used

• Copy constructor- declared only if the user hasn't declared one. Defined if used

• Copy-assignment operatorsame as above

• Destructorsame as above

• 默认构造函数：仅当未声明用户定义的构造函数时才声明。使用时定义

• 复制构造函数- 仅当用户未声明时才声明。定义如果使用

• 复制赋值运算符同上

• 析构函数同上

In C++11 there are two more:

在 C++11 中还有两个：

• Move constructor
• Move-assignment operator

• 移动构造函数
• 移动赋值运算符

It is also possible that the compiler won't be able to generate some of them. For example, if the class contains, for example, a reference (or anything else that cannot be copy-assigned), then the compiler won't be able to generate a copy-assignment operator for you. For more information read this

编译器也可能无法生成其中的一些。例如，如果类包含一个引用（或其他任何不能被复制赋值的东西），那么编译器就不能为你生成一个复制赋值运算符。有关更多信息，请阅读此

回答by Martin York

If I define the following class

如果我定义以下类

class X
{};

The compiler will define the following methods:

编译器将定义以下方法：

X::X()  {}                    // Default constructor. It takes zero arguments (hence default).
X::~X() {}                    // Destructor
X::X(X const& rhs) {};        // Copy constructor
X& operator=(X const& rhs)
{return *this;}              // Assignment operator.

Note:
The default constructor is not built if ANYconstructor is defined.
The other methods are not built if the user defines an alternative.

注意：
如果定义了任何构造函数，则不会构建默认构造函数。
如果用户定义了替代方法，则不会构建其他方法。

What is slightly more interesting is the default implementation when we have members and a base:

更有趣的是当我们有成员和基时的默认实现：

class Y: public X
{
    int    a;      // POD data
    int*   b;      // POD (that also happens to be a pointer)
    Z      z;      // A class
};

// Note: There are two variants of the default constructor.
//       Both are used depending on context when the compiler defined version
//       of the default constructor is used.
//
//       One does `default initialization`
//       One does `zero initialization`

// Objects are zero initialized when
//   They are 'static storage duration'
//   **OR** You use the braces when using the default constructor
Y::Y()      // Zero initializer
    : X()   // Zero initializer
    , a(0)
    , b(0)
    , z()   // Zero initializer of Z called.
{}

// Objects are default initialized when
//    They are 'automatic storage duration'
//    **AND** don't use the braces when using the default constructor
Y::Y()
    :X    // Not legal syntax trying to portray default initialization of X (base class)
    //,a  // POD: uninitialized.
    //,b  // POD: uninitialized.
    ,z    // Not legal syntax trying to portray default initialization of z (member)
{}
//
// Note: It is actually hard to correctly zero initialize a 'automatic storage duration'
//       variable (because of the parsing problems it tends to end up a a function
//       declaration). Thus in a function context member variables can have indeterminate
//       values because of default initialization. Thus it is always good practice to 
//       to initialize all members of your class during construction (preferably in the
//       initialization list).
//
// Note: This was defined this way so that the C++ is backward compatible with C.
//       And obeys the rule of don't do more than you need too (because we want the C++
//       code to be as fast and efficient as possible.


Y::Y(Y const& rhs)
    :X(rhs)              // Copy construct the base
    ,a(rhs.a)            // Copy construct each member using the copy constructor.
    ,b(rhs.b)            // NOTE: The order is explicitly defined
    ,z(rhs.z)            //       as the order of declaration in the class.
{}

Y& operator=(Y const& rhs)
{
    X::operator=(rhs);   // Use base assignment operator
    a  = rhs.a;          // Use the assignment operator on each member.
    b  = rhs.b;          // NOTE: The order is explicitly defined
    z  = rhs.z;          //       as the order of declaration in the class.
    return(*this);
}

Y::~Y()
{
    Your Code first
}
// Not legal code. Trying to show what happens.
  : ~z()
  , ~b() // Does nothing for pointers.
  , ~a() // Does nothing for POD types
  , ~X() ; // Base class destructed last.

回答by Victor Stepanov

Just to expand on Armen Tsirunyan answerhere are the signatures for the methods:

只是为了扩展Armen Tsirunyan的答案，这里是方法的签名：

// C++03
MyClass();                                     // Default constructor
MyClass(const MyClass& other);                 // Copy constructor
MyClass& operator=(const MyClass& other);      // Copy assignment operator
~MyClass();                                    // Destructor

// C++11 adds two more
MyClass(MyClass&& other) noexcept;             // Move constructor
MyClass& operator=(MyClass&& other) noexcept;  // Move assignment operator

回答by rvkreddy

Default methods assigned by compiler for a empty class:

编译器为空类分配的默认方法：

http://cplusplusinterviews.blogspot.sg/2015/04/compiler-default-methods.html

http://cplusplusinterviews.blogspot.sg/2015/04/compiler-default-methods.html

回答by Prasoon Saurav

Is that it?

是这样吗？

Yes thats it.

对，就是那样。

Compiler generates by default

编译器默认生成

• A default constructor
• A copy constructor
• A copy assignment operator
• A destructor

• 默认构造函数
• 复制构造函数
• 复制赋值运算符
• 析构函数

for a class

为一个班级

You can see the default constructor, the copy constructor and the assignment operator being generated by default when you use -ast-dumpoption of Clang

当您使用-ast-dumpClang 的选项时，您可以看到默认生成的默认构造函数、复制构造函数和赋值运算符

prasoon@prasoon-desktop ~ $ cat empty.cpp && clang++ -cc1 -ast-dump empty.cpp
class empty
{};

int main()
{
   empty e;
   empty e2 = e;
   {
     empty e3;
     e3 = e;
   }

}
typedef char *__builtin_va_list;
class empty {
    class empty;
    inline empty() throw(); //default c-tor
    //copy c-tor
    inline empty(empty const &) throw() (CompoundStmt 0xa0b1050 <empty.cpp:1:7>)

    //assignment operator   
    inline empty &operator=(empty const &) throw() (CompoundStmt 0xa0b1590 <empty.cpp:1:7>
  (ReturnStmt 0xa0b1578 <col:7>
    (UnaryOperator 0xa0b1558 <col:7> 'class empty' prefix '*'
      (CXXThisExpr 0xa0b1538 <col:7> 'class empty *' this))))


};