Por favor explique esta expresión

Question

class TestPtr : protected QSharedPointer<Test>

dónde Test es una clase de interfaz abstracta. los TestPtr La clase debería servir como la clase Smart Pointer.

¿Esto significa clase? TestPtr se deriva de la clase Test ? ¿La prueba de clase está encerrada en un puntero inteligente? yo lei eso QSharedPointer es una clase de plantilla. ¿Alguien podría aclarar?

Answer 1

Lo que no significa

1. Que TestPtr deriva de Test -- no es asi.
2. Que class Test está encerrado en un puntero inteligente (pero cerca: significa que instancias de TestPtr en realidad serán consejos inteligentes para Test sin hacer que el mundo lo sepa, excepto como autor de TestPtr elige explícitamente)

Lo que significa

Esto significa que TestPtr quiere implementar la funcionalidad de un puntero inteligente para Test (Que es que QSharedPointer<Test> es, tenga en cuenta que no tengo idea exactamente de qué QSharedPointer lo hace, estoy "leyendo lo que hay en el nombre").

Para lograr esto, el autor de TestPtr planea utilizar ampliamente la funcionalidad integrada en las obras internas de QSharedPointer (es por eso TestPtr hereda en lugar de tener un QSharedPointer Miembro: para poder usar el protected miembros de QSharedPointer).

Sin embargo, el autor planea TestPtr a no ser equivalente a un QSharedPointer<TestPtr> Incluso si la clase tiene sobre la misma funcionalidad (no sabemos la razón de esto con la información dada). Por eso la herencia no es public.

Answer 2

TestPtr se deriva de la versión particular de la clase de plantilla QSharedPointer que ha sido instanciado con la clase Test como su parámetro de plantilla.

Answer 3

¿Esto significa que la clase TestPTR se deriva de la prueba de clase?

No. TestPtr se deriva de QSharedPointer.

¿La prueba de clase está encerrada en un puntero inteligente?

Sí. Bastante, QSharedPointer<Test> es una clase de puntero inteligente que se administra Test punteros.

Leí que Qsharedpointer es una clase de plantilla. ¿Alguien podría aclarar?

Las plantillas resumen tipos similares a cómo las funciones resumen valores fuera de las operaciones. Por ejemplo,

int i,j; 
...
i = 2*i+1;
j = 2*j+1;

se puede abstraer a:

void foo(int &x) {
    x = 2*x + i;
}

...
int i,j,
...
foo(i);
foo(j);

Del mismo modo, en lugar de tener clases separadas como:

class IntSharedPtr { typedef int value_type; ... };
class FloatSharedPtr { typedef float value_type; ...};

Puedes tener una clase de plantilla:

template <typename _T>
class SharedPtr { typedef _T value_type; ...};

typedef SharedPtr<int> IntSharedPtr;
typedef SharedPtr<float> FloatSharedPtr;

Finalmente, el protected significa que los miembros de QSharedPointer solo son accesibles en un TestPtr por TestPtr y sus descendientes. Suponer TestPtr no anula operator * y tiene un constructor que toma un Test (o referencia a un Test). Entonces lo siguiente fallaría, debido a restricciones de acceso:

int main() {
    Test bar;
    TestPtr pbar(bar);

    *pbar; // Error: QSharedPointer<Test>::operator *() is protected within this context.
}

Answer 4

Qsharedpointer es una clase de plantilla, y la prueba es lo que plantillas.

TestPtr hereda de Qsharedpointer (no prueba, a menos que Qsharedpointer hereda de la prueba, no hay suficiente información en la pregunta para responder esto, pero es posible).

Del nombre parece que Qsharedpointer es un puntero inteligente, pero no estoy familiarizado con esta clase para poder responder.

En términos de herencia protegida, es posible que desee ver lo siguiente

http://www.parashift.com/c++faq-lite/private-inheritance.html

Answer 5

No, la clase TESTPTR no se deriva de la prueba de clase. Clase TestPtr se deriva de

class QSharedPointer<Test>

que es realmente la clase Qsharedpointer, expresada en términos de prueba de clase.

La clase Qsharedpointer es una clase de plantilla, lo que significa una clase que se escribe una vez pero que luego se puede usar para la prueba u otras clases.

Por ejemplo, de manera similar a la clase Qsharedpointer, podría tener una clase como esta:

template <class T>
  class Vector
    {
    };

Entonces podría tener instancias de esta clase vectorial que almacena vectores de cosas diferentes. Por ejemplo Vector<int> es una clase que almacena ints, y Vector<bool> es una clase diferente que almacena booleanos.