Что такое конструктор копий?

class as{
as():a(155){}
int a;
};

class CA
{
   int a;
public:
   CA() : a(0) {}                      // просто конструктор (конструктор по умолчанию)
   CA(CA & Copy) : a(Copy.a) {}  // копирующий конструктор, копирует Copy в создаваемый объект
};

class CA
{
   int a;int b;
public:
   CA() : a(0),b(0) {}                      // просто конструктор (конструктор по умолчанию)
   CA(CA & Copy) : a(Copy.a),b(Copy.b) {}  // копирующий конструктор, копирует Copy в создаваемый объект
};

class CA
{
   int a;int b;
public:
   CA() : a(0),b(0) {}                      // просто конструктор (конструктор по умолчанию)
   CA(CA & Copy) : a(Copy.a),b(Copy.a) {}  // копирующий конструктор, копирует Copy в создаваемый объект
};

#include <cstring>
using namespace std;
////////////////////////////////////////////////////////////////////////////////
class strCount
{
      private:
              int count;
              char *str;
              friend class String;
      public:
             strCount(char *s)
             {
                           int length = strlen(s);
                           str = new char [length+1];
                           strcpy(str, s);
                           count = 1;
                           }
             ~strCount()
             { delete [] str; }
};
////////////////////////////////////////////////////////////////////////////////
class String
{
      private:
              strCount *ptr;
      public:
             String()
             {
                     ptr = new strCount("NULL");
                     }
             String(char *t)
             {
                     ptr = new strCount(t);
                     }
             String(const String &T)    //если не проставить "const" компилятор выдает ошибку
             {                                              // при этом в исходном примере const  не стоит 
                     cout << "\nkopirovanie\n";
                     ptr = T.ptr;
                     (ptr -> count)++;
                     }
             ~String()
             {
                      if(ptr->count == 1)
                      delete ptr;
                      else
                      (ptr->count)--;
                      }
             void display()
             {
                  cout << endl << ptr->str;
                  cout << " addr " << ptr;
                  }
             String& operator = (String& T)
             {
                     cout << "\nprisvaivanie\n";
                     if(ptr->count==1)
                     delete ptr;
                     else
                     (ptr->count)--;
                     ptr = T.ptr;
                     (ptr->count)++;
                     return *this;
                     }
};
////////////////////////////////////////////////////////////////////////////////
int main()
{
    String ss1 = "test test";
    String ss2, ss3;
    ss3 = ss2 = ss1;
    ss1.display();
    ss2.display();
    ss3.display();
    cout << endl;
    system("pause");
    return 0;
}

String ss4 = ss1;
ss4.display();

class 
CA
{
   int *a;
   int *b;
public:
   CA() 
  {
      a = new int(0);
      b = new int(0);
   }                     
   
   ~CA()
   {
         delete a;
         delete b;
   }
};
 
int main()
{
    CA k;
    CA m = k; // вызывается конструктор копирования по умолчанию
 
    return 0;
}

CA(const CA &Copy) // конструктор глубокого копирования
   {
        a = new int(*Copy.a);
        b = new int(*Copy.b); 
   }

class T
{
private:
   T(const T&) {}
};

String ss1 = "test test";

String ss1 = String("test test");

ClassX x0;
// здесь ты делаешь что-то с классом x0, а затем пишешь:
ClassX x1;
x1 = x0;

using namespace std;
class vertu{
    public:
    vertu():ival(0),str(new std::string){}
    vertu(vertu &copy):ival(copy.ival),str(copy.str){}
    int ival;
    std::string* str;
    void operator()(int a,std::string* s){
        ival=a;
        str=s;      
        }   
    };
int main(){
    class vertu vert;
    int k(10);
    std::string sk("Papapap");
    vert(k,&sk);
    std::cout<<vert.ival<<" "<<*vert.str<<std::endl;
    class vertu vert2(vert);
    std::cout<<vert2.ival<<" "<<*vert2.str<<std::endl;
    return 0;
    }

#include <iostream>
using namespace std;
class vertu{
    public:
    vertu():ival(0),q(new int[5]){}
    //vertu(vertu &copy):ival(copy.ival),q(copy.q){}  /*1*/
    //vertu(vertu &copy):ival(copy.ival),q(new int[5]){} /*2*/
    int ival;
    int* q;
    void operator()(int a,int* qq){
        ival=a;
        q=qq;       
        }   
    };
int main(){
    class vertu vert;
    std::cout<<vert.ival<<" "<<*(vert.q)<<std::endl;
    int k(10);
    int sk[5]={1,2,3,4,5};
    vert(k,sk);
    std::cout<<vert.ival<<" "<<*(vert.q)<<std::endl;
    class vertu vert2(vert);
    std::cout<<vert2.ival<<" "<<*(vert2.q)<<std::endl;
    return 0;
    }

~vertu()
{
     delete str;
}

#include <string>
#include <iostream>
using namespace std;
 
class vertu
{
    public:
     vertu() : ival(0), str(new string)
     {}
     
     vertu(const vertu &copy) 
     {
        ival = copy.ival;
        str = new string;
        *str = *copy.str;
    }
     
     int ival;
     string* str;
     
     void operator()(int a, string* s)
     {
        ival = a;
        str = new string;
        *str = *s;
     } 
    
    ~vertu()
    {
        delete str;
    }  
};
 
int main()
{
    vertu vert;
    int k(10);
    string sk("Papapap");
    
    vert(k, &sk);
    cout << vert.ival << " " << *vert.str << endl;
    
    vertu vert2(vert);
    cout << vert2.ival << " " << *vert2.str << endl;
 
    cin.get();
    return 0;
 }

              String(const String &T)            //если не проставить "const" компилятор выдает ошибку
                     {                                 // при этом в исходном примере const  не стоит 
                     cout << "\nkopirovanie\n";
                     ptr = T.ptr;
                     (ptr -> count)++;
                     }