As many C++ textbooks say, “if a class is defined and no constructor is provided, the compiler will implicitly provide a default constructor.”

the following excerpt from the original document of ISO C++ 99:

The default constructor (12.1), copy constructor and copy assignment operator (12.8), and destructor (12.4)

are special member functions. The implementation will
implicitly declare these member functions for a

class type
1. When the program does not declare explicitly them, except as noted in 12.1

will
implicitly define them
If they are used, as specified in 12.1, 12.4 and 12.8.

A default constructor for a class X is a constructor of class X that can be called without an argument. If

there is no user-declared constructor for class X, a default constructor is
implicitly declared. An implicitly-

declared default constructor is an
inline public member of its class.

An implicitly-declared default constructor for a class is
implicitly defined when
it is used to create an object

Declared -defined default constructor, everyone The set of Initializations of The

class that would be performed by a user-written default constructor for that class with
An Empty Meminitial-List (12.6.2) and an Empty Function body. If that user-written default constructor would be illformed,the program is ill-formed. Before the declared -declared default constructor for a class is implicitly

defined, all the implicitly-declared default constructors for its base classes and its nonstatic data members

shall have been implicitly defined. [Note: an implicitly-declared default constructor has an exceptionspecification(15.4).

the following excerpts from “corrigendum to sun xin vc tutorial” :

I said, “C++ also states that if a class does not provide any constructors, then C++ provides a default constructor (provided by the C++ compiler).” this statement is also incorrect, and correct:
If no constructor is defined in a class, the compiler will provide a default constructor only if:
1. If the class has virtual member functions or virtual inheritance parent class (i.e., virtual base class);
2. If the base class of the class has a constructor (either a user-defined constructor or a default constructor provided by the compiler);
3. All non-static object data members in a class that have constructors in their corresponding class (either user-defined constructors or default constructors provided by the compiler).
There are also such words in C++ Primer 14.2:

new users often mistakenly assume that if a default constructor does not exist, the compiler automatically generates a default construct

builds functions and applies them to objects to initialize the data members of the class, for the Account class we define

is not true, and the system neither generates the default constructor nor calls it. For those that contain a class data member or inheritance
The
more complex class, which is partially true, may generate a default constructor, but it will not be built-in or complex
Data members of the
combination, such as Pointers or arrays, provide an initial value.

can also be analyzed from the bottom layer:

C/C++ code

   
    
    
    class
     A
{
    public
    :
        
    int
     a;
        
    char
     
    *
    ptr;
};

    int
     main()
{
        A a;
        
    return
     
    0
    ;
}

The

code does not produce the default ctor, so the class looks like a struct under C, and none of the members need to be initialized.

evidence 1:

Assembly code

   
    
    97
    :   
    int
     main()
    98
    :   {
    0040D680
       
    push
            ebp
    0040D681
       
    mov
             ebp,esp
    0040D683
       
    sub
             esp,48h
    0040D686
       
    push
            ebx
    0040D687
       
    push
            esi
    0040D688
       
    push
            edi
    0040D689
       
    lea
             edi,[ebp-48h]
    0040D68C
       
    mov
             ecx,12h
    0040D691
       
    mov
             eax,0CCCCCCCCh
    0040D696
       
    rep
     stos    dword ptr [edi]  
    99
    :       A a
    ;
                      //Nothing to do
    
    100
    :      return 
    0
    ;
    0040D698
       
    xor
             eax,eax
    101
    :  }
    0040D69A
       
    pop
             edi
    0040D69B
       
    pop
             esi
    0040D69C
       
    pop
             ebx
    0040D69D
       
    mov
             esp,ebp
    0040D69F
       
    pop
             ebp
    0040D6A0
       
    ret
     

</ dl> however,

(1) if a member variable that requires a constructor is added, the default ctor is called, such as STD ::string

C/C++ code

   
    
    
#include 
    <
    string
    >
    
    class
     A
{
    public
    :
    
    int
     a;
    
    char
     
    *
    ptr;
    std::
    string
     test;
};

    int
     main()
{
    A a;
    
    return
     
    0
    ;

}

Assembly code

 

       
        
        
        int
         main()
        99
        :   {
        0040D680
           
        push
                ebp
        0040D681
           
        mov
                 ebp,esp
        0040D683
           
        sub
                 esp,5Ch
        0040D686
           
        push
                ebx
        0040D687
           
        push
                esi
        0040D688
           
        push
                edi
        0040D689
           
        lea
                 edi,[ebp-5Ch]
        0040D68C
           
        mov
                 ecx,17h
        0040D691
           
        mov
                 eax,0CCCCCCCCh
        0040D696
           
        rep
         stos    dword ptr [edi]
        100
        :      A a
        ;
        0040D698
           
        lea
                 ecx,[ebp-18h]
        ;
        this Pointer
        
        0040D69B
           
        call
                @ILT+
        35
        (
        A:
        :A) (
        00401028
        )
        ;
        The defaultctor is called.
        
        101
        :      return 
        0
        ;
        0040D6A0
           
        mov
                 dword ptr [ebp-1Ch],
        0
        
        0040D6A7
           
        lea
                 ecx,[ebp-18h]
        0040D6AA
           
        call
                @ILT+
        40
        (
        A:
        :~A) (
        0040102d
        )
        0040D6AF
           
        mov
                 eax,dword ptr [ebp-1Ch]
        102
        :  }
        0040D6B2
           
        pop
                 edi
        0040D6B3
           
        pop
                 esi
        0040D6B4
           
        pop
                 ebx
        0040D6B5
           
        add
                 esp,5Ch
        0040D6B8
           
        cmp
                 ebp,esp
        0040D6BA
           
        call
                __chkesp (
        00401170
        )
        0040D6BF
           
        mov
                 esp,ebp
        0040D6C1
           
        pop
                 ebp
        0040D6C2
           
        ret
         

(2) has a virtual function and will call the default ctor, such as:

C/C++ code

 [code
    =
    C
    /
    C
    ++
    ]

class A
{
public:
    int a;
    char *ptr;
    virtual void dd(){a=1;}
};

int main()
{
    A a;
    return 0;
}

 

 

corresponding Assembly

Assembly code

   
    
    
    100
    :      A a
    ;
    00401048
       
    lea
             ecx,[ebp-0Ch]
    0040104B
       
    call
            @ILT+
    15
    (
    A:
    :A) (
    00401014
    )
    ;
    The main thing here is to put the first address of the virtual function table into the first four bytes.
     

can be summarized as follows: the compiler always produces the default ctor when it is needed and when the user does not provide it. Doing so yields optimal efficiency.