[C++] ¿Cuándo debería usar una clase frente a una estructura en C ++?


Answers

Como todos los demás observan, en realidad solo hay dos diferencias de lenguaje reales:

  • struct predeterminada en el acceso público y class valores predeterminados de class en acceso privado.
  • Al heredar, struct predeterminada en herencia public y class valores predeterminados de class en herencia private . (Irónicamente, como ocurre con tantas cosas en C ++, el valor predeterminado es al revés: public herencia public es, con mucho, la opción más común, pero las personas rara vez declaran struct s solo para ahorrar al escribir la palabra clave " public ".

Pero la diferencia real en la práctica es entre una class / struct que declara un constructor / destructor y otra que no. Existen ciertas garantías para un tipo de POD "de datos antiguos", que ya no se aplica una vez que se hace cargo de la construcción de la clase. Para mantener esta distinción clara, muchas personas deliberadamente solo usan struct s para los tipos de POD y, si van a agregar algún método, usan class es. La diferencia entre los dos fragmentos a continuación no tiene sentido:

class X
{
  public:

  // ...
};

struct X
{
  // ...
};

(Por cierto, aquí hay un hilo con algunas buenas explicaciones sobre lo que realmente significa el "tipo de POD": ¿Qué son los tipos de POD en C ++? )

Question

¿En qué escenarios es mejor usar una struct frente a una class en C ++?




Las estructuras de forma predeterminada tienen acceso público y las clases de forma predeterminada tienen acceso privado.

Personalmente utilizo estructuras para objetos de transferencia de datos o como objetos de valor. Cuando se usa como tal, declaro que todos los miembros son const para evitar modificaciones por otro código.




Nunca uso "struct" en C ++.

No puedo imaginar un escenario en el que usarías una estructura cuando quieres miembros privados, a menos que intentes confundir intencionalmente.

Parece que el uso de estructuras es más una indicación sintáctica de cómo se usarán los datos, pero prefiero simplemente hacer una clase y tratar de hacerlo explícito en el nombre de la clase, o mediante comentarios.

P.ej

class PublicInputData {
    //data members
 };



La única vez que uso una estructura en lugar de una clase es cuando declaro un funtor justo antes de usarlo en una llamada a función y quiero minimizar la sintaxis en aras de la claridad. p.ej:

struct Compare { bool operator() { ... } };
std::sort(collection.begin(), collection.end(), Compare()); 



Un lugar donde una estructura ha sido útil para mí es cuando tengo un sistema que está recibiendo mensajes de formato fijo (por ejemplo, un puerto serie) de otro sistema. Puede convertir la secuencia de bytes en una estructura que defina sus campos y luego acceder fácilmente a los campos.

typedef struct
{
    int messageId;
    int messageCounter;
    int messageData;
} tMessageType;

void processMessage(unsigned char *rawMessage)
{
    tMessageType *messageFields = (tMessageType *)rawMessage;
    printf("MessageId is %d\n", messageFields->messageId);
}

Obviamente, esta es la misma cosa que harías en C, pero creo que la sobrecarga de tener que decodificar el mensaje en una clase generalmente no vale la pena.




Una ventaja de struct over class es que guarda una línea de código, si se adhiere a "primeros miembros públicos, luego privados". En este sentido, creo que la class palabra clave es inútil.

Aquí hay otra razón para usar solo struct y never class . Algunas pautas de estilo de código para C ++ sugieren el uso de letras minúsculas para las macros de funciones; la razón fundamental es que cuando la macro se convierte en una función en línea, no es necesario cambiar el nombre. Igual que aquí. Usted tiene su estructura tipo C agradable y un día, descubre que necesita agregar un constructor o algún método de conveniencia. ¿Lo cambias a una class ? ¿En todos lados?

Distinguir entre las struct y las class es demasiada molestia, entrar en el camino de hacer lo que deberíamos hacer: programar. Al igual que muchos de los problemas de C ++, surge del fuerte deseo de compatibilidad hacia atrás.




Clase.

Los miembros de la clase son privados por defecto.

class test_one {
    int main_one();
};

Es equivalente a

class test_one {
  private:
    int main_one();
};

Entonces, si lo intentas

int two = one.main_one();

main_one is private un error: main_one is private porque no es accesible. Podemos resolverlo inicializándolo especificando que es un público

class test_one {
  public:
    int main_one();
};

Struct.

Una estructura es una clase donde los miembros son públicos por defecto.

struct test_one {
    int main_one;
};

Significa main_one es privado ie

class test_one {
  public:
    int main_one;
};

Utilizo estructuras para estructuras de datos donde los miembros pueden tomar cualquier valor, es más fácil de esa manera.




Técnicamente, ambos son iguales en C ++, por ejemplo, es posible que una estructura tenga operadores sobrecargados, etc.

Sin embargo :

Uso estructuras cuando deseo pasar información de varios tipos simultáneamente. Utilizo clases cuando trato con un objeto "funcional".

Espero eso ayude.

#include <string>
#include <map>
using namespace std;

struct student
{
    int age;
    string name;
    map<string, int> grades
};

class ClassRoom
{
    typedef map<string, student> student_map;
  public :
    student getStudentByName(string name) const 
    { student_map::const_iterator m_it = students.find(name); return m_it->second; }
  private :
    student_map students;
};

Por ejemplo, estoy devolviendo un alumno struct en los métodos get ... () aquí - enjoy.




Para C ++, realmente no hay mucha diferencia entre las estructuras y las clases. La principal diferencia funcional es que los miembros de una estructura son públicos por defecto, mientras que son privados por defecto en las clases. De lo contrario, en lo que respecta al idioma, son equivalentes.

Dicho esto, tiendo a usar estructuras en C ++ como lo hago en C #, similar a lo que Brian dijo. Las estructuras son contenedores de datos simples, mientras que las clases se usan para objetos que necesitan actuar sobre los datos además de simplemente aferrarse a ellos.




Son más o menos lo mismo. Gracias a la magia de C ++, una estructura puede contener funciones, usar herencia, crearse con "nuevo" y así sucesivamente, al igual que una clase

La única diferencia funcional es que una clase comienza con derechos de acceso privados, mientras que una estructura comienza con pública. Esta es la compatibilidad retroactiva con C.

En la práctica, siempre he usado estructuras como titulares de datos y clases como objetos.




Como todos dicen, la única diferencia real es el acceso predeterminado. Pero particularmente uso struct cuando no quiero ningún tipo de encapsulación con una clase de datos simple, incluso si implemento algunos métodos de ayuda. Por ejemplo, cuando necesito algo como esto:

struct myvec {
    int x;
    int y;
    int z;

    int length() {return x+y+z;}
};