Có bao nhiêu phương thức mặc định của một lớp?

Question

Xin lỗi, điều này có vẻ đơn giản, nhưng ai đó đã hỏi tôi điều này, và tôi không biết chắc chắn.

Lớp C++ trống đi kèm với chức năng nào?

Constructor, Sao chép Constructor, Bài tập, Destructor?

Có phải không? Hay có nhiều hơn?

Answer 1

Trong C++ 03 có 4:

• Mặc định constructor: khai báo chỉ khi không có hàm tạo do người dùng xác định nào được khai báo là . Được xác định khi được sử dụng

• Trình tạo bản sao - chỉ được khai báo nếu người dùng chưa khai báo. Xác định nếu sử dụng

• hành Copy-phân tương tự như trên

• Destructor tương tự như trên

Trong C++ 11 có hai hơn:

• Di chuyển hàm tạo
• Move-nhiệm vụ điều hành

Nó cũng có thể là trình biên dịch sẽ không thể tạo ra một số trong số họ. Ví dụ, nếu lớp chứa, ví dụ, một tham chiếu (hoặc bất kỳ thứ gì khác không thể được gán bản sao), thì trình biên dịch sẽ không thể tạo một toán tử gán bản sao cho bạn.For more information read this

Answer 2

Có phải không?

Có thats it.

trình biên dịch tạo ra theo mặc định

• Một constructor mặc định
• Một constructor sao chép
• Một toán tử gán bản sao
• Destructor

cho một lớp

Bạn có thể xem defa ult constructor, các nhà xây dựng bản sao và toán tử gán được tạo ra theo mặc định khi bạn sử dụng tùy chọn -ast-dump Clang

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)))) 


}; 

Answer 3

Nếu tôi xác định các lớp sau

class X 
{}; 

Trình biên dịch sẽ xác định các phương pháp sau:

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. 

Lưu ý:
Các constructor mặc định không được xây dựng nếu BẤT CỨ constructor được định nghĩa .
Các phương pháp khác không được xây dựng nếu người dùng xác định phương án thay thế.

gì là hơi thú vị hơn là việc thực hiện mặc định khi chúng tôi có các thành viên và cơ sở:

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. 

Answer 4

Mặc định phương pháp bởi trình biên dịch được gán cho một lớp học trống:

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

Answer 5

Chỉ cần để mở rộng trên Armen Tsirunyan answer dưới đây là chữ ký cho các phương pháp:

// 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