Есть полиморфная иерархия классов. Необходимо запретить создание объектов классов этой иерархии в памяти стека(например: Type ob; // должно приводить к ошибке компиляции), а разрешить только в динамической(с помощью new)? При этом производные классы изменять недопустимо, можно только базовый.

Здравствуйте, Аноним, Вы писали:

А>Есть полиморфная иерархия классов. Необходимо запретить создание объектов классов этой иерархии в памяти стека(например: Type ob; // должно приводить к ошибке компиляции), а разрешить только в динамической(с помощью new)? При этом производные классы изменять недопустимо, можно только базовый.

Перенести деструктор в защищенную секцию

Здравствуйте, placement_new, Вы писали:

_>Перенести деструктор в защищенную секцию

Твой никнейм как бы намекает...

_>Перенести деструктор в защищенную секцию

Унаследоваться от такого класса — и вперед.

Здравствуйте, K13, Вы писали:

_>>Перенести деструктор в защищенную секцию

K13>Унаследоваться от такого класса — и вперед.

Поясните, что вы имеете в виду
Вот как я понял вашу рекомендацию:

class A
{
protected:
  virtual ~A() {}
};

class B : public A
{
};

int main()
{
  B b;
  return 0;
}

но этот код у меня компилируется =\
как сделать. чтобы не компилировалось?

Здравствуйте, placement_new, Вы писали:

_>Здравствуйте, Аноним, Вы писали:

А>>Есть полиморфная иерархия классов. Необходимо запретить создание объектов классов этой иерархии в памяти стека(например: Type ob; // должно приводить к ошибке компиляции), а разрешить только в динамической(с помощью new)? При этом производные классы изменять недопустимо, можно только базовый.

_>Перенести деструктор в защищенную секцию

в protected? Тогда в производных классах также нужно сделать деструктор protected, но согласно начальному условию, изменять производные классы нельзя. А если в потомках оставить деструктор public, то объекты можно создавать в стековой памяти.

Здравствуйте, placement_new, Вы писали:

_>Перенести деструктор в защищенную секцию

лучше в private

class A
{
public:
    static A * Create()
    {
        return new A();
    }
private:
    A()
    {
    };
};

Здравствуйте, dabeat_bf, Вы писали:

_>Здравствуйте, placement_new, Вы писали:

_>>Перенести деструктор в защищенную секцию

_>лучше в private


_>

_>class A
_>{
_>public:
_>    static A * Create()
_>    {
_>        return new A();
_>    }
_>private:
_>    A()
_>    {
_>    };
_>};
_>

тогда нельзя создать объект производного от А класса никаким спосом

Здравствуйте, Аноним, Вы писали:

А>При этом производные классы изменять недопустимо, можно только базовый.

Спрячь наследников и предоставь фабрики, которые будут возвращать std::auto_ptr<Base>.
Тогда все клиенты отвалятся и будут вынуждены использовать фабрики =)

Здравствуйте, niralex, Вы писали:

N>тогда нельзя создать объект производного от А класса никаким спосом

можно так:

class A
{
public:
    static A * Create()
    {
        return new A();
    }
private:
    A()
    {
    };
};

class B : public A
{
public:
    B() : A(*A::Create())
    {
    };
};

Здравствуйте, dabeat_bf, Вы писали:

_>можно так:

_>

_>class A
_>{
_>public:
_>    static A * Create()
_>    {
_>        return new A();
_>    }
_>private:
_>    A()
_>    {
_>    };
_>};

_>class B : public A
_>{
_>public:
_>      // а здесь имеем утечку - конструктор копии отработает,
_>      // но вот его аргумент, живущий в куче, потеряется.
_>    B() : A(*A::Create())
_>    {
_>    };
_>};
_>

_>>можно так:
_>> // а здесь имеем утечку — конструктор копии отработает,
_>> // но вот его аргумент, живущий в куче, потеряется.
_>> B() : A(*A::Create())
_>> {
_>> };
_>>};
_>>[/ccode]

это все зависит от того, как конструктор копирования будет выглядеть

на самом деле задача не тривиальная, как следствие решение (если таковое есть) будет тоже извращенным

Здравствуйте, dabeat_bf, Вы писали:

_>это все зависит от того, как конструктор копирования будет выглядеть
_>на самом деле задача не тривиальная, как следствие решение (если таковое есть) будет тоже извращенным

Насколько я знаю, нормального решения именно для иерархии при такой постановке нет.
Пока единственное хоть сколько-нибудь рабочее — заныкать иерархию и отдавать через фабрики. Тоже метод в общем-то.

А по поводу конструктора копии —

A(const A& other)
{
    // ... здесь конструируем
    // ... а потом - серпом по яйцам!
    A* ptr = const_cast<A*>(&other);
    delete A;
}

Это имеете ввиду?

Думаю, не нужно говорить, что случится, если кто-то, создавая иерархию, передаст туда временный объект...

Здравствуйте, Мишень-сан, Вы писали:

МС>А по поводу конструктора копии —
МС>

МС>A(const A& other)
МС>{
МС>    // ... здесь конструируем
МС>    // ... а потом - серпом по яйцам!
МС>    A* ptr = const_cast<A*>(&other);
МС>    delete A;
МС>}
МС>

МС>Это имеете ввиду?

МС>Думаю, не нужно говорить, что случится, если кто-то, создавая иерархию, передаст туда временный объект...

я не говрил о конкретной реализации, но придумать что-то можно, например в вашем случае если передавать в конструктор копирования не константную ссылку, то временный объект туда никто не передаст, но опять таки нужно думать чтоб придумать что-то стоящее я просто предложил направление для размышления

Здравствуйте, Мишень-сан, Вы писали:

например так можно так попробовать:

class A
{
public:
    static A * Create()
    {
        return new A();
    }
protected:
    A(A &a)
    {
        //копируем
        //........
        //........
        //удаляем
        A * a_ =  &a;
        delete a_;
    };

    A(const A & a)
    {
        //копируем 
        //........
        //........
        //и не удаляем
    };
private:
    A()
    {
    };
};

class B : public A
{
public:
    B() : A(*A::Create())
    {
    };
};

Здравствуйте, Аноним, Вы писали:

А>Есть полиморфная иерархия классов. Необходимо запретить создание объектов классов этой иерархии в памяти стека(например: Type ob; // должно приводить к ошибке компиляции), а разрешить только в динамической(с помощью new)? При этом производные классы изменять недопустимо, можно только базовый.

А зачем всё это надо?

Можно, например, завести какой-нибудь объект, к которому у наследников нет доступа, и чисто-виртуальный метод, в реализации которого нужен доступ к этому объекту, ну и вперёд. Создавать объекты производных классов сможет только твоя фабрика

class CrazyFactory {
    struct CSeed { };
    template<typename T> class RealObject : public T {
        CSeed CheckSeed( CSeed s ) { return s; }
    };
public:
    class Root {
    public:
        virtual ~Root() {};
    private:
        virtual CSeed CheckSeed( CSeed ) = 0;
    };

    template<typename T> Root* CreateNewObject() { return new RealObject<T>(); }
};

class CrazyFactory {
    struct CSeed { };
    template<typename T> class RealObject : public T {
        CSeed CheckSeed( CSeed s ) { return s; }
    };
public:
    class Root {
    public:
        virtual ~Root() {};
    private:
        virtual CSeed CheckSeed( CSeed ) = 0;
    };

    template<typename T> T* CreateNewObject() { return new RealObject<T>(); }
};

Здравствуйте, Erop, Вы писали:

E>А зачем всё это надо?

Наверно у них какой-то объект стек портит и они защищаются таким образом от порчи стека.

Здравствуйте, Feonyf, Вы писали:

F>Наверно у них какой-то объект стек портит и они защищаются таким образом от порчи стека.

О! Тогда можно подзажечь по-взрослому:

class NoStackObject {
    enum { MaxDiff = sizeof( void* ) * 16 };
    void checkThis() const
    {
        char a;
        int diff = &a - (const char*)this;
        assert( -MaxDiff <= diff && diff <= MaxDiff );
    }

public:
    NoStackObject() { checkThis(); }
    NoStackObject( const NoStackObject& ) { checkThis(); }
};

Здравствуйте, Erop, Вы писали:

E>

class CrazyFactory {
E>    struct CSeed { };
E>    template<typename T> class RealObject : public T {
E>        CSeed CheckSeed( CSeed s ) { return s; }
E>    };
E>public:
E>    class Root {
E>    public:
E>        virtual ~Root() {};
E>    private:
E>        virtual CSeed CheckSeed( CSeed ) = 0;
E>    };

E>    template<typename T> T* CreateNewObject() { return new RealObject<T>(); }
E>};
E>

Красиво... Это то, что надо.