no puede miembro privado de acceso declarado en un error al crear la instancia de clase de plantilla

Question

Mi código es el siguiente

template <typename T> 

class name 
{ 
public: 
    name() : h_(0){} 

    template <typename U> 
    operator name<U>() 
    { 
     name<U> u; 
     u.h_ = h_; 
     return u; 
    } 
private: 
    int h_; 
}; 

int main(void) 
{ 
    name<int> a; 
    name<double> b = a; 
    return 0; 
} 

El error que consigo es int name<double>::h_ is private. ¿Cómo arreglar el error?

Answer 1

name<T> y name<U> son vistas por el compilador como dos clases diferentes, y no le permite acceder a miembros privados de la otra clase. ¿Como arreglarlo? O rediseña o otorga amistad. O proporcione acceso ... Hay muchas maneras de hacerlo, la más adecuada depende de su intención. Si adivino correctamente tu intención, es una buena idea conceder amistad, pero no puedo ver la imagen completa del código que publicaste.

Answer 2

Deberá agregar setters/getters (o amistad, o alguna otra cosa). El problema es que name<T> y name<U> son clases completamente independientes.

Alternativamente, ¿por qué no agrega otro constructor name(const T &h) : h_(h) {}?

Answer 3

name<int> y name<double> son ejemplos diferentes, y por lo tanto son en realidad diferentes clases. Sus miembros privados no pueden ser compartidos por defecto. Necesita hacer name<T> amigo a todos los demás name 's.

template <typename T> 

class name 
{ 
public: 
    name() : h_(0){} 

    template <typename U> 
    operator name<U>() 
    { 
     name<U> u; 
     u.h_ = h_; 
     return u; 
    } 
private: 
    int h_; 
    template <typename> // <-- 
    friend class name; // <-- 
}; 

int main(void) 
{ 
    name<int> a; 
    name<double> b = a; 
    return 0; 
} 

Answer 4

name<T> puede ser diferente de name<U> [por ejemplo: en su caso]. Por lo tanto, no se puede acceder a los miembros privados de la otra [en caso de que T y U sean tipos diferentes].

Agregue lo siguiente a su definición de clase.

template<typename U> 
friend class name; 

Answer 5

Name<T> es potencialmente un tipo diferente a Name<U>, por lo que se aplican las reglas de encapsulación. Usa accesos o amigos.

Answer 6

name<int> intenta acceder a un miembro privado de name<double>. Debería poder solucionarlo haciendo que la función de conversión sea amiga, pero los compiladores probé go havoc if you try.

También podría hacer cualquier name<T> un amigo de name<U> para solucionar esto.

template <typename T> 
class name 
{ 
public: 
    name() : h_(0){} 

    template <typename U> 
    operator name<U>() 
    { 
     name<U> u; 
     u.h_ = h_; 
     return u; 
    } 

    template<typename U> 
    friend class name; // <---- 

private: 
    int h_; 
};