Необходимо чтобы один и тот же объект не мог создаться пока преведущий существует.

Примерно это выглядет так

CClass object;

CClass object1;
//невозможно создание подобного объекта, до того момента пока существует первый

Возможное решение моей задачи например
При создании второго объекта первый просто удаляется или удаляются все подобные!

R>Необходимо чтобы один и тот же объект не мог создаться пока преведущий существует.

Не подойдет ли паттерн "одиночка" (singleton)?

class MyClass;

MyClass& GetMyObject();

class Myclass
{
    friend MyClass& GetMyObject();
private:
    MyClass();
...
};

MyClass& GetMyObject()
{
    static MyClass myObject;
    return myObject;
}

Теперь можно получить ссылку на единственный экземпляр класса MyClass, т.е. создать их несколько одновременно нельзя. Обрати внимание, что конструктор помещен в приватную секцию класса, а функция GetMyObject() объявлена дружественной, что позволяет создание объектов класса только при помощи GetMyObject().

несовсем непонятно когда это должно происходить, во время компиляции?
тогда, например, препроцессором

#define DECLARE_OBJ(p) { #ifndef DECLARE_CLONE CClass (p); #define DECLARE_CLONE 1 #endif};
#define DELETE_OBJ(p) { #ifdef DECLARE_CLONE delete (p); #undef DECLARE_CLONE #endif};

...
DECLARE_OBJ (object); //объявляем

DECLARE_OBJ (object1); //непойдеть(наверно:)

DELETE_OBJ (object); //удаляем

DECLARE_OBJ (object1); //теперь объявится

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

R>Необходимо чтобы один и тот же объект не мог создаться пока преведущий существует.
R>
R>Примерно это выглядет так
R>
R>CClass object;
R>
R>CClass object1;
R>//невозможно создание подобного объекта, до того момента пока существует первый

R>Возможное решение моей задачи например
R>При создании второго объекта первый просто удаляется или удаляются все подобные!

Счетчик ссылок может быть?

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

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

R>>Необходимо чтобы один и тот же объект не мог создаться пока преведущий существует.
R>>
R>>Примерно это выглядет так
R>>
R>>CClass object;
R>>
R>>CClass object1;
R>>//невозможно создание подобного объекта, до того момента пока существует первый

R>>Возможное решение моей задачи например
R>>При создании второго объекта первый просто удаляется или удаляются все подобные!

B>Счетчик ссылок может быть?

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

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

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

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

R>>>Необходимо чтобы один и тот же объект не мог создаться пока преведущий существует.
R>>>
R>>>Примерно это выглядет так
R>>>
R>>>CClass object;
R>>>
R>>>CClass object1;
R>>>//невозможно создание подобного объекта, до того момента пока существует первый

R>>>Возможное решение моей задачи например
R>>>При создании второго объекта первый просто удаляется или удаляются все подобные!

B>>Счетчик ссылок может быть?

R>Да это наверное наиболее простой способ решения но тогда мы зависим от глобальной, по отношению к данному объекту, переменной т.е. от Бога, а это не есть хорошо!

Почему же глобальной? Можно создать статическую переменную класса. Вот так:

class Singletons
{
    // operations

public:
        static Singletons& GetInstance();
        static void DestroyInstance();

    // implementation

private:
    Singletons();
    ~Singletons();

    static Singletons *pThis_;
    static unsigned nInstanceCount_;

};

Singletons& Singletons::GetInstance()
{
    if( !pThis_ )
        new Singletons;
    return *pThis_;
}

void Singletons::DestroyInstance()
{
    delete pThis_;
    pThis_ = 0;
}

Singletons *Singletons::pThis_ = 0;
unsigned Singletons::nInstanceCount_ = 0;

Singletons::Singletons( CMainFrame *mainframe )
{
    TRACE( TEXT("----Singletons ctor\n") );

    ASSERT( &mainframe_ );

    VERIFY( ! nInstanceCount_++ );
    pThis_ = this;
}

Singletons::~Singletons()
{
    TRACE( TEXT("----Singletons dtor\n") );

    VERIFY( ! --nInstanceCount_ );
}

Можно было бы реализовать метод класса GetInstance() при помощи статической переменной функции и возвращения ссылки на нее, но тогда мы не смогли бы контролировать время жизни объекта.

Singletons::Singletons( CMainFrame *mainframe ) — sorry — хреново вычистил код — класс большой

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



ME>Почему же глобальной? Можно создать статическую переменную класса. Вот так:

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

Ты имеешь ввиду что-то типа:

class T
{
   public:
T(){ObCount++;}
~T(){ObCount--;}

static int GetCounts(){return ObCount;}
   private:
int x;
static int ObCount
};

int T::ObCount = 0;

int main()
{
T* pOb = new T[5];
cout<<"Имеем"<<T::GetCounts()<<"Объектов типа Т \n";
delete pOb;
return 0;
}

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

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

R>

ME>>Почему же глобальной? Можно создать статическую переменную класса. Вот так:

R>Статический член класса может рассматриваться как глобальная переменная или функция, доступная только в пределах области класса.

R>Ты имеешь ввиду что-то типа:

Статический член класса может рассматриваться именно как член класса, не объекта. Член класса существует вне зависимости от наличия экземпляров данного класса.

Повторюсь — если тебе не нужно контролировать время жизни объекта можно обойтись без счетчиков и проверки указателей, а воспользоваться статической переменной функции.

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

R>Необходимо чтобы один и тот же объект не мог создаться пока преведущий существует.
R>
R>Примерно это выглядет так
R>
R>CClass object;
R>
R>CClass object1;
R>//невозможно создание подобного объекта, до того момента пока существует первый

R>Возможное решение моей задачи например
R>При создании второго объекта первый просто удаляется или удаляются все подобные!

Возможное решение проблемы — применение паттерна "одиночка" (singleton)
Основная идея — сделать конструктор protected, чтобы запретить явное создание объекта,
и предоставить static public метод для получения указателя на объект...

получится что-то типа
CClass* obj;
CClass* obj1;

obj = CClass.Instance(); //получили указатель на объект
obj1 = CClass.Instance(); //результат зависит от внутренней реализации, в примитиве — тот же самый указатель

Здравствуйте Kapusto, Вы писали:
......
K>obj = CClass.Instance(); //получили указатель на объект
K>obj1 = CClass.Instance(); //результат зависит от внутренней реализации, в примитиве — тот же самый указатель

Так это получается какой-то оператор копирования объета существующего в единственном числе, или я чегно-то не понимаю? Или создаются постоянно новые объекты под одим именем?

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

R>Так это получается какой-то оператор копирования объета существующего в единственном числе, или я чегно-то не понимаю? Или создаются постоянно новые объекты под одим именем?

Идея паттерна singleton в том, что ты не можешь явно создавать объекты, ты можешь лишь получить ссылку или указатель на единственный объект данного класса.