Notas de estudio del artículo 11 de "C ++ moderno efectivo": se prefiere la función de eliminación en lugar de la función privada indefinida

Si implementa una determinada clase para que la usen otros programadores, pero no quiere que él use una función específica, entonces simplemente no podemos declarar la función. Pero si el compilador genera automáticamente esta función, como la función de asignación predeterminada, ¿qué debemos hacer?

La práctica en C ++ 98 es declarar la función como privada, para evitar que el exterior la llame directamente, y luego no la definimos, de modo que cuando la función miembro de esta clase llame a la función por error, un Se le pedirá un error de enlace. P.ej:

class Test {
public:
    void Fix(Test& t) {
        Test t1;
        t1 = t;  //编译报错,使用未定义函数
    }
private:
    Test& operator=(const Test& t);//只声明，不定义
};

Test t1,t2;
t1 = t2;   //编译报错，private权限问题

Pero C ++ 11 agregó una nueva palabra clave para nosotros, que puede resolver fácilmente este problema, es decir, la palabra clave eliminar. Para el mismo código que el anterior, solo necesita agregar eliminar después de la función de asignación.

class Test {
public:
    void Fix(Test& t) {
        Test t1;
        t1 = t;  //编译报错,使用delete函数
    }

    Test& operator=(const Test& t) = delete;//只声明，不定义
};

Test t1,t2;
t1 = t2;   //编译报错,使用delete函数

Otra ventaja de usar eliminar es que eliminar no solo puede modificar funciones miembro, sino que también las funciones globales ordinarias pueden usar eliminar, especialmente en el caso de sobrecarga de funciones, eliminar sigue siendo muy útil, porque aunque esta función se elimina, sigue siendo una parte del programa, y ​​aún se tendrá en cuenta al volver a cargar la resolución. En particular, cuando la función de eliminación finalmente coincida, se mostrará un error de compilación.

//无delete场景
bool isLove(int);

isLove(12); //匹配到isLove(int)
isLove(false);//false隐式转换为int，匹配到isLove(int)
isLove(3.5);//double隐式转换为int，匹配到isLove(int)


//使用delete场景
bool isLove(int);
bool isLove(bool) = delete;
bool isLove(double) = delete;

isLove(12); //匹配到isLove(int)
isLove(false);//匹配到isLove(bool),因其为删除函数，编译报错
isLove(3.5); //匹配到isLove(double)，因其为删除函数，编译报错

En el siguiente escenario, tendrá que usar delete, es decir, para borrar un cierto tipo de función de realización de una determinada función de plantilla (función miembro o función global). Esto solo se puede hacer con la ayuda de la palabra clave delete:

//全局函数
template<class T>
void TestFunc(T* ptr);

template<>
void TestFunc<void>(void*) = delete;   //删除该模板的void类型具现

template<>
void TestFunc<char>(char*) = delete;   //删除该模板的char类型具现


//成员函数，类内类外均可删除
class TestClass{
public:
    template<class T>
    void TestFunc2(T* ptr);
    
    template<>
    void TestFunc2<void>(void*) = delete;   //类内删除该模板的void类型具现
};

template<>
void TestClass::TestFunc2<char>(char*) = delete;   //类外删除该模板的char类型具现

Taquigrafía

• Se prefiere la función de eliminación en lugar de la función privada indefinida
• Se puede eliminar cualquier función, incluidas las funciones miembro, las funciones no miembro y la realización de plantillas.