Специальный дизайн класса - C++

Language 2023-05-05 05:46:48 views: null

Каталог статей

1. Пожалуйста, создайте класс, который нельзя скопировать

Копирование будет выпущено только в двух сценариях: конструктор копирования и перегрузка оператора присваивания, поэтому, если вы хотите запретить копирование класса, вам нужно только сделать так, чтобы класс не мог вызывать конструктор копирования и перегрузку оператора присваивания.

С++ 98

Перегрузка конструктора копирования и оператора присваивания только объявляет отсутствие определения и устанавливает его права доступа как частные.

class CopyBan
{
    
    
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};

причина:

  1. Установить как приватный: Если только оператор не установлен как приватный, если пользователь определяет его вне класса,
    копирование не может быть запрещено.
  2. Только объявлять, но не определять: не определять, потому что функция вообще не будет вызываться, а определять ее бессмысленно, просто если не написать, а если определить, то это не помешает внутреннему копированию функций-членов.
     

С++ 11

C++ 11 расширяет использование удаления.В дополнение к освобождению ресурсов, запрошенных new, если удаление следует за функцией-членом по умолчанию с =
delete, это означает, что компилятор удаляет функцию-член по умолчанию.

class CopyBan
{
    
    
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};

 
 

2. Пожалуйста, создайте класс, который может создавать объекты только в куче.

Метод реализации:

2.1 Сделать конструктор класса закрытым, а конструкцию копии объявить закрытой. Не позволяйте другим вызывать копию для создания объектов в стеке.

//只能在堆上建立对象
class HeapOnly
{
    
    
    //正确释放对象的方法
public:
    
    /*static void Delete(HeapOnly* p)
    {
        delete p;
    }*/

    void Delete()
    {
    
    
        delete this;
    }

private:
    //1. 析构函数私有（这个方法hp1和hp2不能使用）
    ~HeapOnly()
    {
    
    
        cout << "~HeapOnly()" << endl;
    }
private:
    int _a;
};

int main()
{
    
    
    /*HeapOnly hp1;
    static HeapOnly hp2;*/

    HeapOnly* ptr = new HeapOnly;//自定义类型不调析构
    //delete ptr;//此时第一种方法，不能释放对象
    //HeapOnly::Delete(ptr);
    ptr->Delete();

    return 0;
}

вставьте сюда описание изображения

 
 

2.2 Предоставьте статическую функцию-член, в которой завершено создание объекта кучи

//只能在堆上建立对象
class HeapOnly
{
    
    
public:
    //提供公有创建对象(获取对象的方式）的一个类，对象控制是new出来了的
    static HeapOnly* CreateObj()
    {
    
    
        return new HeapOnly;
    }
    
    //防拷贝
    HeapOnly(const HeapOnly& hp) = delete;
    HeapOnly& operator=(const HeapOnly& hp) = delete;
private:
    
    //2. 构造函数私有（三个都限制住了）
    HeapOnly()
        :_a(0)
    {
    
    }
private:
    int _a;
};

int main()
{
    
    
    //HeapOnly hp1;
    //static HeapOnly hp2;

    //HeapOnly* hp3 = new HeapOnly;//自定义类型不调析构
    //delete hp3;
    
    HeapOnly* hp3 = HeapOnly::CreateObj();//自定义类型不调析构
    //HeapOnly copy(*hp3);//拷贝构造
    
    delete hp3;

    return 0;
}

 
 

3. Пожалуйста, создайте класс, который может создавать объекты только в стеке.

Как и выше, приватизируйте конструктор, а затем разработайте статический метод для создания объекта и его возврата.Недостаток
: создание копии нельзя полностью ограничить .

// 只能在栈上创建对象
class StackOnly
{
    
    
public:
    static StackOnly CreateObj()
    {
    
    
        StackOnly st;
        return st;
    }

    // 不能防拷贝
    //StackOnly(const StackOnly& st) = delete;
    //StackOnly& operator=(const StackOnly& st) = delete;
    void* operator new(size_t n) = delete;
private:
    // 构造函数私有
    StackOnly()
        :_a(0)
    {
    
    }
private:
    int _a;
};

int main()
{
    
    
    /*StackOnly st1;
    static StackOnly st2;
    StackOnly* st3 = new StackOnly;*/

    StackOnly* st1 = StackOnly::CreateObj();

    //拷贝构造
    static StackOnly copy2(st1);//不好处理
    //StackOnly* copy3 = new StackOnly(st1);

    return 0;


}

 
 

4. Пожалуйста, создайте класс, который не может быть унаследован

С++ 98 способ

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
    
    
public:
static NonInherit GetInstance()
{
    
    
return NonInherit();
}
private:
NonInherit()
{
    
    }
};

 

Метод С++ 11

Ключевое слово final, окончательный измененный класс, означает, что класс не может быть унаследован.

class A final
{
    
    
// ....
};

 
 

5. Пожалуйста, создайте класс, который может создавать только один объект (одноэлементный режим).

设计模式:
Шаблон проектирования (Design Pattern) — это краткое изложение набора опыта проектирования кода, который многократно используется, известен большинству людей и классифицируется.
Почему существует такая вещь, как шаблон проектирования? Точно так же, как развитие человеческой истории породит искусство войны. В начале,
когда племена воевали друг против друга, они воевали друг против друга. Позже, в периоды Весны и Осени и Сражающихся царств, Семь королевств часто вели войны, и они обнаружили, что существуют боевые действия.Позже Сунь-Цзы резюмировал «Искусство войны Сунь-Цзы». «Искусство войны» Сунь-Цзы похоже.

使用设计模式的目的:
для повторного использования кода сделайте его более понятным для других и обеспечьте надежность кода. Шаблоны проектирования
делают написание кода по-настоящему инженерным; шаблоны проектирования являются краеугольным камнем разработки программного обеспечения, точно так же, как структура здания.

单例模式:
В процессе
класс может создать только один объект, то есть одноэлементный режим, который может гарантировать, что в системе есть только один экземпляр класса, и предоставить глобальную точку доступа для доступа к нему, которая совместно используется все программные модули. Например, в серверной программе информация о конфигурации сервера хранится в файле, и эти данные о конфигурации единообразно считываются одноэлементным объектом, а затем другие объекты в процессе службы получают информацию о конфигурации через этот одноэлементный объект, который Такой подход упрощает управление конфигурацией в сложных средах.

Существует два режима реализации одноэлементного режима:

режим голодного человека

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

//饿汉模式——一开始（mian函数之前）就创建出对象
// 优点：简单、没有线程安全问题
// 缺点：
// 1、一个程序中，多个单例，并且有先后创建初始化顺序要求时，饿汉无法控制。
// 比如程序两个单例类A 和 B，假设要求A先创建初始化，B再创建初始化。
// 2、饿汉单例类，初始化时任务多，会影响程序启动速度。
class MemoryPool
{
    
    
public:

private:
    // 构造函数私有化
    MemoryPool()
    {
    
    }

    char* _ptr = nullptr;
    // ...

    static MemoryPool _inst; // 声明
};

// 定义
MemoryPool MemoryPool::_inst;

class MemoryPool
{
    
    
public:
    static MemoryPool* GetInstance()
    {
    
    
        return _pinst;
    }

    void* Alloc(size_t n)
    {
    
    
        void* ptr = nullptr;
        // ....
        return ptr;
    }

    void Dealloc(void* ptr)
    {
    
    
        // ...
    }

private:
    // 构造函数私有化
    MemoryPool()
    {
    
    }

    char* _ptr = nullptr;
    // ...

    static MemoryPool* _pinst; // 声明
};

// 定义
MemoryPool* MemoryPool::_pinst = new MemoryPool;

int main()
{
    
    
    //MemoryPool pool1;
    //MemoryPool pool2;

    void* ptr1 = MemoryPool::GetInstance()->Alloc(10);
    MemoryPool::GetInstance()->Dealloc(ptr1);
}

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

 
 

ленивый режим

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

// 懒汉模式：第一次使用对象再创建实例对象
// 优点：
// 1、控制顺序。
// 2、不影响启动速度。

// 缺点：
// 1、相对复杂。（线程安全问题没讲）
// 2、线程安全问题要处理好
class MemoryPool
{
    
    
public:
    static MemoryPool* GetInstance()
    {
    
    
        if (_pinst == nullptr)
        {
    
    
            _pinst = new MemoryPool;
        }

        return _pinst;
    }

    void* Alloc(size_t n)
    {
    
    
        void* ptr = nullptr;
        // ....
        return ptr;
    }

    void Dealloc(void* ptr)
    {
    
    
        // ...
    }

    // 实现一个内嵌垃圾回收类    
    class CGarbo {
    
    
    public:
        ~CGarbo()
        {
    
    
            if (_pinst)
                delete _pinst;
        }
    };

private:
    // 构造函数私有化
    MemoryPool()
    {
    
    
        // ....
    }

    char* _ptr = nullptr;
    // ...

    static MemoryPool* _pinst; // 声明
};

// 定义
MemoryPool* MemoryPool::_pinst = nullptr;

// 回收对象，main函数结束后，他会调用析构函数，就会释放单例对象
static MemoryPool::CGarbo gc;


// 单例对象释放问题：
// 1、一般情况下，单例对象不需要释放的。因为一般整个程序运行期间都可能会用它。
// 单例对象在进程正常结束后，也会资源释放。
// 2、有些特殊场景需要释放，比如单例对象析构时，要进行一些持久化(往文件、数据库写)操作。
// 

int main()
{
    
    
    //MemoryPool pool1;
    //MemoryPool pool2;

    void* ptr1 = MemoryPool::GetInstance()->Alloc(10);
    MemoryPool::GetInstance()->Dealloc(ptr1);
}

Supongo que te gusta

Origin blog.csdn.net/Ll_R_lL/article/details/128919998
Recomendado
Clasificación
Diario
Más
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)

Code World

© 2018 codetd.com