class ClassA : public QObject 
{
};

....
....
....

list <ClassA> Alist;
ClassA A1;
Alist.push_back(A1);

    list <ClassA *> Alist;
    ClassA *A1 = new ClassA();
    Alist.push_back(A1);

Qt Objects: Identity vs Value

Some of the added features listed above for the Qt Object Model, require that we think of Qt Objects as identities, not values. Values are copied or assigned; identities are cloned. Cloning means to create a new identity, not an exact copy of the old one. For example, twins have different identities. They may look identical, but they have different names, different locations, and may have completely different social networks.

Then cloning an identity is a more complex operation than copying or assigning a value. We can see what this means in the Qt Object Model.

A Qt Object...

* might have a unique QObject::objectName(). If we copy a Qt Object, what name should we give the copy?
* has a location in an object hierarchy. If we copy a Qt Object, where should the copy be located?
* can be connected to other Qt Objects to emit signals to them or to receive signals emitted by them. If we copy a Qt Object, how should we transfer these connections to the copy?
* can have new properties added to it at runtime that are not declared in the C++ class. If we copy a Qt Object, should the copy include the properties that were added to the original?

For these reasons, Qt Objects should be treated as identities, not as values. Identities are cloned, not copied or assigned, and cloning an identity is a more complex operation than copying or assigning a value. Therefore, QObject and all subclasses of QObject (direct or indirect) have their copy constructor and assignment operator disabled.

class ClassA : public QObject
{
public:
    ClassA(){};
    ClassA( const ClassA &s )  { }
    ClassA& operator=( const ClassA &s )  {  return *this; }
};

    list <ClassA> Alist2;
    ClassA A2;
    Alist2.push_back(A2);

ClassA( const ClassA &s )  { }

G>class ClassA : public QObject
G>{
G>public:
G>    ClassA(){};
G>    ClassA( const ClassA &s )  { }
G>    ClassA& operator=( const ClassA &s )  {  return *this; }
G>};

G>

G>    list <ClassA> Alist2;
G>    ClassA A2;
G>    Alist2.push_back(A2);
G>

G>ClassA( const ClassA &s )  { }
G>

ClassA( const ClassA &s )
    : a_( s.a_ )
    , b_( s.b_ )
{ }

G>ClassA( const ClassA &s )  { }
G>

ClassA( const ClassA &s )  { }
ClassA& operator=( const ClassA &s )  {  return *this; }

class CopirableQObject : public QObject
{
public:
    CopirableQObject(){};
    CopirableQObject( const CopirableQObject &s )  { }
    CopirableQObject& operator=( const CopirableQObject &s )  {  return *this; }
};

class ClassA : public CopirableQObject
{
  // Здесь конструктор копирования определять уже не нужно. 
  // Конструктор по умолчанию, сделает ровно то что ты хочешь.
}