c++ - una - ventajas de struct con respecto a class




¿Cuáles son las diferencias entre estructura y clase en C++? (19)

Esta pregunta ya se hizo en el contexto de C # / .Net .

Ahora me gustaría aprender las diferencias entre una estructura y una clase en C ++. Discuta las diferencias técnicas así como las razones para elegir una u otra en el diseño OO.

Comenzaré con una diferencia obvia:

  • Si no especifica public: o private: miembros de una estructura son públicos de forma predeterminada; los miembros de una clase son privados por defecto

Estoy seguro de que hay otras diferencias que se encuentran en los rincones oscuros de la especificación de C ++.


ISO IEC 14882-2003

9 clases

§3

Una estructura es una clase definida con la struct class-key ; sus miembros y clases base (cláusula 10) son públicas por defecto (cláusula 11).


  1. Los miembros de una estructura son públicos por defecto, los miembros de la clase son privados por defecto.
  2. La herencia predeterminada para la Estructura de otra estructura o clase es pública. La herencia predeterminada para la clase de otra estructura o clase es privada.
class A{    
public:    
    int i;      
};

class A2:A{    
};

struct A3:A{    
};


struct abc{    
    int i;
};

struct abc2:abc{    
};

class abc3:abc{
};


int _tmain(int argc, _TCHAR* argv[])
{    
    abc2 objabc;
    objabc.i = 10;

    A3 ob;
    ob.i = 10;

    //A2 obja; //privately inherited
    //obja.i = 10;

    //abc3 obss;
    //obss.i = 10;
}

Esto es en VS2005.


Aunque está implícito en otras respuestas, no se menciona explícitamente: las estructuras son compatibles con C, dependiendo del uso; las clases no son

Esto significa que si está escribiendo un encabezado que quiere ser compatible con C, entonces no tiene otra opción que struct (que en el mundo C no puede tener funciones, pero sí puede tener punteros de función).


Citando las preguntas frecuentes de C ++ ,

[7.8] ¿Cuál es la diferencia entre la estructura y la clase de palabras clave?

Los miembros y las clases base de una estructura son públicos por defecto, mientras que en clase, por defecto son privados. Nota: debe hacer que sus clases base sean explícitamente públicas, privadas o protegidas, en lugar de confiar en los valores predeterminados.

Struct y clase son funcionalmente equivalentes.

OK, basta de esa charla de techno reluciente. Emocionalmente, la mayoría de los desarrolladores hacen una fuerte distinción entre una clase y una estructura. Una estructura simplemente se siente como una pila abierta de bits con muy poca forma de encapsulación o funcionalidad. Una clase se siente como un miembro vivo y responsable de la sociedad con servicios inteligentes, una barrera de encapsulación fuerte y una interfaz bien definida. Ya que esa es la connotación que la mayoría de la gente ya tiene, probablemente debería usar la palabra clave struct si tiene una clase que tiene muy pocos métodos y datos públicos (¡tales cosas existen en sistemas bien diseñados!), Pero de lo contrario probablemente debería usar la clase palabra clave.


Encontré otra diferencia. Si no define un constructor en una clase, el compilador definirá uno. pero en una estructura si no define un constructor, el compilador tampoco define un constructor. por lo tanto, en algunos casos que realmente no necesitamos un constructor, struct es una mejor opción (punta de rendimiento). Y lo siento por mi mal inglés.


Es sólo una convención. Se pueden crear estructuras para almacenar datos simples pero luego evolucionar el tiempo con la adición de funciones miembro y constructores. Por otro lado, es inusual ver algo que no sea público: acceso en una estructura.


La clase solo tiene sentido en el contexto de la ingeniería de software. En el contexto de las estructuras de datos y algoritmos, clase y estructura no son tan diferentes. No hay ninguna regla restringida a la que se deba hacer referencia al miembro de la clase.

Al desarrollar un proyecto grande con toneladas de personas sin clase, finalmente puede obtener un código combinado complicado porque todos usan las funciones y los datos que desean. la clase proporciona controles de permisos y inherentes para mejorar el desacoplamiento y la reutilización de códigos.

Si lees algunos principios de ingeniería de software, encontrarás que la mayoría de los estándares no se pueden implementar fácilmente sin clase. por ejemplo: http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

Por cierto, cuando una estructura asigna un crujido de memoria e incluye varias variables, las variables de tipo de valor indican que los valores están integrados en el lugar donde se asigna la estructura. En contraste, los valores de la variable de tipo de referencia son externos y la referencia por un puntero que también está incrustado en donde se asigna la estructura.


La diferencia entre las palabras clave struct y class en C ++ es que, cuando no hay un especificador específico en un tipo de datos compuesto en particular, struct o union por defecto son las palabras clave públicas que simplemente consideran la ocultación de datos, pero class es la palabra clave privada que considera la ocultación del programa. Códigos o datos. Siempre algunos programadores usan struct para datos y clases por código. Para más información contacte con otras fuentes.


La principal diferencia entre struct y class es que in struct solo puede declarar variables de datos de diferentes tipos de datos, mientras que en class puede declarar variables de datos, funciones miembro y, por lo tanto, puede manipular variables de datos a través de funciones.

-> otra cosa útil que encuentro en clase vs estructura es que al implementar archivos en un programa, si desea realizar algunas operaciones de una estructura una y otra vez en cada nuevo conjunto de operaciones, necesita hacer una función separada y necesita Pase el objeto de estructura después de leerlo del archivo para realizar algunas operaciones en él. en clase, si realiza una función que realiza algunas operaciones con los datos necesarios cada vez ... es fácil, solo tiene que leer el objeto desde el archivo y llamar a la función.

Pero depende del programador la forma en que lo encuentre adecuado ... de acuerdo con mi preferencia, prefiero la clase cada vez, simplemente porque es compatible con los OOP y esa es la razón por la que se implementa en casi todos los idiomas y es la característica maravillosa de la programación de todos los tiempos; )

Y sí, la diferencia más no olvidada que olvidé mencionar es que la clase admite la ocultación de datos y también las operaciones que se realizan en los tipos de datos integrados, ¡mientras que struct no!


Las clases son tipos de referencia y las estructuras son tipos de valores.
Cuando digo que las clases son tipos de referencia,
Básicamente contendrán la dirección de una variable de instancia.

Por ejemplo:

Class MyClass
{
    Public Int DataMember;  //By default, accessibility of class data members 
                            //will be private. So I am making it as Public which 
                            //can be accessed outside of the class.
}

En el método principal,
Puedo crear una instancia de esta clase usando un nuevo operador que asigna memoria para esta clase
y almacena la dirección base de eso en la variable de tipo MyClass (_myClassObject2).

Static Public void Main (string[] arg)
{
    MyClass _myClassObject1 = new MyClass();
    _myClassObject1.DataMember = 10;

    MyClass _myClassObject2 = _myClassObject1;
    _myClassObject2.DataMember=20;
}

En el programa anterior, MyClass _myClassObject2 = _myClassObject1; La instrucción indica que ambas variables de tipo MyClass.

  1. myClassObject1
  2. myClassObject2

y apuntará a la misma ubicación de memoria.
Básicamente, asigna la misma ubicación de memoria a otra variable del mismo tipo.

Entonces, si cualquier cambio que realicemos en cualquiera de los objetos tipo MyClass tendrá un efecto en otro
ya que ambos están apuntando a la misma ubicación de memoria.

"_myClassObject1.DataMember = 10;" en esta línea, ambos miembros de datos del objeto contendrán el valor de 10.
"_myClassObject2.DataMember = 20;" en esta línea, tanto el miembro de datos del objeto contendrá el valor de 20.
Eventualmente, estamos accediendo a los miembros de datos de un objeto a través de punteros.

A diferencia de las clases, las estructuras son tipos de valor. Por ejemplo:

Structure MyStructure
{
    Public Int DataMember;  //By default, accessibility of Structure data 
                            //members will be private. So I am making it as 
                            //Public which can be accessed out side of the structure.
}

Static Public void Main (string[] arg)
{
    MyStructure _myStructObject1 = new MyStructure();
    _myStructObject1.DataMember = 10;

    MyStructure _myStructObject2 = _myStructObject1;
    _myStructObject2.DataMember = 20;
}

En el programa anterior,
instanciar el objeto de tipo MyStructure utilizando un nuevo operador y
almacenamiento de la dirección en la variable _myStructObject de tipo MyStructure y
asignando el valor 10 al miembro de datos de la estructura usando "_myStructObject1.DataMember = 10".

En la siguiente línea,
Estoy declarando otra variable _myStructObject2 de tipo MyStructure y asignando _myStructObject1 a eso.
Aquí .NET C # compiler crea otra copia del objeto _myStructureObject1 y
asigna esa ubicación de memoria a la variable MyStructure _myStructObject2.

Entonces, cualquier cambio que hagamos en _myStructObject1 nunca tendrá un efecto en otra variable _myStructObject2 de tipo MyStructrue.
Por eso decimos que las estructuras son tipos de valor.

Por lo tanto, la clase Base inmediata para la clase es Objeto y la clase Base inmediata para la Estructura es ValueType que se hereda de Objeto.
Las clases soportarán una herencia mientras que las estructuras no lo harán.

¿Cómo estamos diciendo eso?
¿Y cuál es la razón detrás de eso?
La respuesta es Clases.

Puede ser abstracto, sellado, estático, parcial y no puede ser privado, protegido y protegido interno.


Los miembros de la clase son privados por defecto. Los miembros de Struct son públicos por defecto. Además de eso no hay otras diferencias. También vea esta pregunta .


No en la especificación, no. La principal diferencia está en las expectativas del programador cuando leen su código en 2 años. Se suele suponer que las estructuras son POD. Las estructuras también se usan en la metaprogramación de plantillas cuando está definiendo un tipo para fines que no son los objetos.


Otra diferencia importante es cuando se trata de plantillas. Por lo que sé, puede usar una clase cuando define una plantilla pero NO una estructura.

template<class T> // OK
template<struct T> // ERROR, struct not allowed here

Puede considerar esto para las pautas sobre cuándo ir a la estructura o la clase, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .

√ CONSIDERE la definición de una estructura en lugar de una clase si las instancias del tipo son pequeñas y, por lo general, duran poco o están comúnmente incrustadas en otros objetos.

X EVITA definir una estructura a menos que el tipo tenga todas las características siguientes:

Lógicamente representa un solo valor, similar a los tipos primitivos (int, double, etc.).

Tiene un tamaño de instancia inferior a 16 bytes.

Es inmutable.

No tendrá que ser boxeado con frecuencia.


Según Stroustrup en el lenguaje de programación C ++ :

El estilo que uses depende de las circunstancias y el gusto. Normalmente prefiero usar struct para las clases que tienen todos los datos públicos. Pienso en tales clases como "tipos no muy adecuados, solo estructuras de datos".

Funcionalmente, no hay otra diferencia que la pública / privada.


Te olvidas de la complicada segunda diferencia entre clases y estructuras.

Califique el estándar (§11.2.2 en C ++ 98 a C ++ 11):

En ausencia de un especificador de acceso para una clase base, se asume público cuando la clase derivada se declara struct y se asume privado cuando la clase se declara clase .

Y solo para completar, la diferencia más ampliamente conocida entre clase y estructura se define en (11.2):

Los miembros de una clase definida con la palabra clave clase son privados por defecto. Los miembros de una clase definida con la estructura de palabras clave o unión son públicos de forma predeterminada.

Diferencia adicional: la class palabra clave se puede usar para declarar parámetros de plantilla, mientras que la palabra clave struct no se puede usar así.


Veo otra diferencia entre las estructuras y las clases que tienen que ver con la inicialización predeterminada.

struct Foo {
    int a;
};

class Bar {
    int a;
};

class Tester {
    Foo m_Foo = Foo();
    Bar m_Bar = Bar();

public:
    Tester() {}
};

int main() {
    auto myTester = Tester();
}

Ejecute ese código y examine myTester. Encontrará que para m_Foo, la estructura, m_Foo.a se ha inicializado a 0, pero para m_Bar, la clase, m_Bar.a no está inicializada. Entonces, parece que hay una diferencia en lo que hace el constructor predeterminado para la estructura vs clase. Estoy viendo esto con Visual Studio.


1) Los miembros de una clase son privados por defecto y los miembros de struct son públicos por defecto.

Por ejemplo, el programa 1 falla en la compilación y el programa 2 funciona bien.

// Program 1
#include <stdio.h>

class Test {
    int x; // x is private
};
int main()
{
  Test t;
  t.x = 20; // compiler error because x is private
  getchar();
  return 0;
}
Run on IDE
// Program 2
#include <stdio.h>

struct Test {
    int x; // x is public
};
int main()
{
  Test t;
  t.x = 20; // works fine because x is public
  getchar();
  return 0;
}

2) Cuando se deriva una estructura de una clase / estructura, el especificador de acceso predeterminado para una clase / estructura base es público. Y cuando se deriva una clase, el especificador de acceso predeterminado es privado.

Por ejemplo, el programa 3 falla en la compilación y el programa 4 funciona bien.

// Program 3
#include <stdio.h>

class Base {
public:
    int x;
};

class Derived : Base { }; // is equilalent to class Derived : private Base {}

int main()
{
  Derived d;
  d.x = 20; // compiler error becuase inheritance is private
  getchar();
  return 0;
}
Run on IDE
// Program 4
#include <stdio.h>

class Base {
public:
    int x;
};

struct Derived : Base { }; // is equilalent to struct Derived : public Base {}

int main()
{
  Derived d;
  d.x = 20; // works fine becuase inheritance is public
  getchar();
  return 0;
}

  • . En las clases, todos los miembros por defecto son privados, pero en la estructura los miembros son públicos por defecto.

    1. No hay un término como constructor y destructor para las estructuras, pero el compilador de la clase crea un valor predeterminado si no lo proporciona.

    2. El tamaño de la estructura vacía es de 0 bytes, mientras que el tamaño de la clase vacía es de 1 byte. El tipo de acceso predeterminado de la estructura es público. Una estructura normalmente se debe utilizar para agrupar datos.

    El tipo de acceso predeterminado de la clase es privado y el modo predeterminado para la herencia es privado. Se debe utilizar una clase para agrupar datos y métodos que operan con esos datos.

    En resumen, la convención es usar struct cuando el propósito es agrupar datos, y usar clases cuando necesitamos abstracción de datos y, tal vez, herencia.

    En C ++, las estructuras y las clases se pasan por valor, a menos que estén explícitamente sin referencia. En otros idiomas, las clases y estructuras pueden tener semánticas distintas, es decir, los objetos (instancias de clases) pueden pasarse por referencia y las estructuras pueden pasarse por valor. Nota: hay comentarios asociados con esta pregunta. Vea la página de discusión para agregar a la conversación.





c++-faq