¿Cuáles son las diferencias entre struct y class en C ++?

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:, los 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 en los rincones oscuros de la especificación C ++.

Olvidas la difícil segunda diferencia entre clases y estructuras.

Quoth 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 public cuando la clase derivada se declara struct y private se asume cuando la clase se declara clase .

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

Los miembros de una clase definida con la clase de palabra clave son privados de forma predeterminada. Los miembros de una clase definida con las palabras clave struct o union son públicos de forma predeterminada.

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

Citando las preguntas frecuentes de C ++ ,

[7.8] ¿Cuál es la diferencia entre las palabras clave struct y class?

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

Estructura y clase son funcionalmente equivalentes.

Bien, suficiente de esa charla techno chirriante y limpia. 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 encapsulación o funcionalidad. Una clase se siente como un miembro vivo y responsable de la sociedad con servicios inteligentes, una fuerte barrera de encapsulación y una interfaz bien definida. Dado 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 tiene datos públicos (¡tales cosas existen en sistemas bien diseñados!), Pero de lo contrario, probablemente debería usar la clase palabra clave.

Vale la pena recordar los orígenes y compatibilidad de C ++ en C.

C tiene estructuras, no tiene concepto de encapsulación, por lo que todo es público.

Ser público por defecto generalmente se considera una mala idea cuando se adopta un enfoque orientado a objetos, por lo que al hacer una forma de C que sea conducente de forma nativa a la POO (puede hacer OO en C, pero no lo ayudará), que fue el idea en C ++ (originalmente "C con clases"), tiene sentido hacer que los miembros sean privados de forma predeterminada.

Por otro lado, si Stroustrup hubiera cambiado la semántica de structmodo que sus miembros fueran privados por defecto, habría roto la compatibilidad (ya no es tan cierto como los estándares divergieron, pero todos los programas C válidos también eran programas C ++ válidos, que tuvo un gran efecto al dar a C ++ un punto de apoyo).

Entonces, classse introdujo una nueva palabra clave para que sea exactamente como una estructura, pero privada de forma predeterminada.

Si C ++ hubiera venido desde cero, sin historial, entonces probablemente solo tendría una de esas palabras clave. Probablemente tampoco habría tenido el impacto que causó.

En general, las personas tenderán a usar struct cuando están haciendo algo como cómo se usan structs en C; miembros públicos, sin constructor (siempre y cuando no esté en una unión, puede tener constructores en estructuras, al igual que con las clases, pero las personas tienden a no hacerlo), no hay métodos virtuales, etc. Dado que los idiomas son tanto para comunicarse con las personas que leen el código para instruir a las máquinas (o de lo contrario nos quedaríamos con el ensamblaje y los códigos de máquina virtual sin procesar) es una buena idea seguir con eso.

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 .

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

El estilo que uses depende de las circunstancias y el gusto. Por lo general, prefiero usar structpara clases que tienen todos los datos públicos. Pienso en tales clases como "tipos no del todo adecuados, solo estructuras de datos".

Funcionalmente, no hay diferencia aparte de lo público / privado

STRUCT es un tipo de tipo de datos abstractos que divide un fragmento de memoria dado de acuerdo con la especificación de la estructura. Las estructuras son particularmente útiles en la serialización / deserialización de archivos, ya que la estructura a menudo se puede escribir en el archivo literalmente. (es decir, obtenga un puntero a la estructura, use la macro SIZE para calcular el número de bytes que se copiarán, luego mueva los datos dentro o fuera de la estructura).

Las clases son un tipo diferente de tipo de datos abstractos que intentan garantizar el ocultamiento de la información. Internamente, puede haber una variedad de maquinaciones, métodos, variables temporales, variables de estado. etc. que se utilizan para presentar una API coherente a cualquier código que desee utilizar la clase.

En efecto, las estructuras son sobre datos, las clases son sobre código.

Sin embargo, debe comprender que se trata simplemente de abstracciones. Es perfectamente posible crear estructuras que se parezcan mucho a clases y clases que se parezcan mucho a estructuras. De hecho, los primeros compiladores de C ++ eran simplemente precompiladores que traducen el código de C ++ a C. Por lo tanto, estas abstracciones son un beneficio para el pensamiento lógico, no necesariamente un activo para la computadora misma.

Más allá del hecho de que cada uno es un tipo diferente de abstracción, las clases brindan soluciones al rompecabezas de nombres de código C. Como no puede tener más de una función expuesta con el mismo nombre, los desarrolladores solían seguir un patrón de _ (). por ejemplo, mathlibextreme_max (). Al agrupar las API en clases, funciones similares (aquí las llamamos "métodos") se pueden agrupar y proteger de la denominación de métodos en otras clases. Esto permite al programador organizar mejor su código y aumentar la reutilización del código. En teoría, al menos.

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) Al derivar una estructura de una clase / estructura, el especificador de acceso predeterminado para una clase / estructura base es público. Y al derivar 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;
}

La única otra diferencia es la herencia predeterminada de clases y estructuras, que, como era de esperar, es privada y pública, respectivamente.

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 está en VS2005.

No en la especificación, no. La principal diferencia está en las expectativas del programador cuando leen su código en 2 años. a menudo se supone que las estructuras son POD. Las estructuras también se utilizan en la metaprogramación de plantillas cuando se define un tipo para fines distintos de la definición de objetos.

Otra cosa a tener en cuenta, si actualizó una aplicación heredada que tenía estructuras para usar clases, podría encontrarse con el siguiente problema:

El código antiguo tiene estructuras, el código se limpió y estos se cambiaron a clases. Luego se agregó una o dos funciones virtuales a la nueva clase actualizada.

Cuando las funciones virtuales están en clases, internamente el compilador agregará un puntero adicional a los datos de la clase para apuntar a las funciones.

Cómo esto rompería el antiguo código heredado es si en el antiguo código en algún lugar se borró la estructura usando memfill para borrar todo a ceros, esto también pisotearía los datos adicionales del puntero.

1. Los miembros de una clase definida con la palabra clave classson privatepor defecto. Los miembros de una clase definida con las palabras clave struct(o union) son publicpor defecto.

2. En ausencia de un especificador de acceso para una clase base, publicse asume cuando se declara la clase derivadastruct y privatese asume cuando se declara la clase class.

3. Puedes declarar un enum classpero no un enum struct.

4. Puedes usar template<class T>pero no template<struct T>.

Tenga en cuenta también que el estándar C ++ le permite declarar hacia adelante un tipo como a struct, y luego usarlo classal declarar el tipo y viceversa. Además, std::is_class<Y>::valuees truepara Y siendo a structy a class, pero es falsepara un enum class.

La diferencia entre classy structes una diferencia entre palabras clave, no entre tipos de datos. Estos dos

struct foo : foo_base { int x;};
class bar : bar_base { int x; };

ambos definen un tipo de clase. La diferencia de las palabras clave en este contexto es el acceso predeterminado diferente:

• foo::xes público y foo_basese hereda públicamente
• bar::xes privado y bar_basese hereda en privado

Aquí hay una buena explicación: http://carcino.gen.nz/tech/cpp/struct_vs_class.php

Entonces, una vez más: en C ++, una estructura es idéntica a una clase, excepto que los miembros de una estructura tienen visibilidad pública por defecto, pero los miembros de una clase tienen visibilidad privada por defecto.

Es solo una convención. Se pueden crear estructuras para contener 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.

ISO IEC 14882-2003

9 clases

§3

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

Otra diferencia principal es cuando se trata de plantillas. Hasta donde yo 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

Las otras respuestas han mencionado los valores predeterminados privados / públicos (pero tenga en cuenta que una estructura es una clase es una estructura; no son dos elementos diferentes, solo dos formas de definir el mismo elemento).

Lo que podría ser interesante notar (particularmente porque es probable que el autor de la pregunta esté usando MSVC ++ ya que menciona C ++ "no administrado") es que Visual C ++ se queja bajo ciertas circunstancias si una clase se declara con classy luego se define con struct(o posiblemente al revés) ), aunque el estándar dice que es perfectamente legal.

• . 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 para el compilador de clases crea un valor predeterminado si no 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 usar una clase para agrupar datos y métodos que operan en esos datos.

  En resumen, la convención es usar struct cuando el propósito es agrupar datos, y usar clases cuando requerimos abstracción de datos y, quizás, herencia.

  En C ++, las estructuras y clases se pasan por valor, a menos que se haga una referencia explícita. En otros idiomas, las clases y estructuras pueden tener una semántica distinta, es decir. los objetos (instancias de clases) se pueden pasar por referencia y las estructuras se pueden pasar por valor. Nota: Hay comentarios asociados con esta pregunta. Vea la página de discusión para agregar a la conversación.

Si bien lo implican 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 desea que sea compatible con C, entonces no tiene otra opción que no sea struct (que en el mundo C no puede tener funciones; pero puede tener punteros de función).

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

√ CONSIDERA definir una estructura en lugar de una clase si las instancias del tipo son pequeñas y comúnmente de corta duración o están incrustadas comúnmente en otros objetos.

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

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

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

Es inmutable.

No tendrá que ser encuadrado con frecuencia.

La clase solo tiene sentido en el contexto de la ingeniería de software. En el contexto de estructuras de datos y algoritmos, la clase y la 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 gran proyecto con toneladas de personas sin clase, finalmente puede obtener un código acoplado complicado porque todos usan las funciones y los datos que desean. La clase proporciona controles de permisos e inherentes para mejorar el desacoplamiento y la reutilización de códigos.

Si lee algunos principios de ingeniería de software, encontrará 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 incorporados en el lugar donde se asigna la estructura. Por el contrario, los valores de la variable de tipo de referencia son externos y 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 particular, por defecto struct o union 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 class por código. Para más información contacte a otras fuentes.

De todos estos factores, se puede concluir que la clase de concepto es muy adecuada para representar objetos del mundo real en lugar de "estructuras". En gran medida porque los conceptos de POO utilizados en clase son muy prácticos para explicar escenarios del mundo real, por lo tanto, es más fácil fusionarlos con la realidad. Por ejemplo, la herencia predeterminada es pública para las estructuras, pero si aplicamos esta regla para el mundo real, es ridículo, pero en una clase la herencia predeterminada es privada, lo que es más realista.

De todos modos, lo que necesito para justificar es que Class es un concepto mucho más amplio y aplicable en el mundo real, mientras que Structure es un concepto primitivo con una organización interna deficiente (aunque la estructura sigue los conceptos de OOP, tienen un significado pobre)

La principal diferencia entre la estructura y la palabra clave de clase en oops es que no hay ninguna declaración de miembro pública y privada presente en la estructura, y el miembro de datos y la función de miembro se pueden definir como públicos, privados y protegidos.

** ACTUALIZACIÓN: ** Por favor ignore esta respuesta. No consideré la posibilidad de que para la estructura, el valor no se haya inicializado, pero resultó ser 0. No hay una diferencia de inicialización entre estructura y clase.

Estoy viendo 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 haber una diferencia en lo que hace el constructor predeterminado para struct vs. class. Estoy viendo esto con Visual Studio.

La principal diferencia entre struct y class es que en struct solo puede declarar variables de datos de diferentes tipos de datos, mientras que en clase 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 class vs struct 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, debe realizar una función separada y debe pase el objeto de struct después de leerlo del archivo para realizar algunas operaciones en él. mientras está en clase si realiza una función que realiza algunas operaciones sobre los datos necesarios cada vez ... es fácil, solo tiene que leer el objeto del archivo y llamar a la función ...

Pero depende del programador de qué manera él / ella lo encuentra adecuado ... según yo, prefiero la clase cada vez solo porque admite 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 olvidada que olvidé mencionar es que la clase admite la ocultación de datos y también admite operaciones que se realizan en tipos de datos integrados mientras que struct no lo hace.

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. Entonces, en algunos casos en los que realmente no necesitamos un constructor, struct es una mejor opción (consejo de rendimiento). y perdón por mi mal inglés.

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 la misma 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 hacemos en cualquiera de los objetos, escriba MyClass, tendrá un efecto en otro,
ya que ambos apuntan a la misma ubicación de memoria.

"_myClassObject1.DataMember = 10;" en esta línea, los 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.
Finalmente, 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,
crea una instancia del objeto de tipo MyStructure usando un nuevo operador y
almacenando 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,
declaro otra variable _myStructObject2 de tipo MyStructure y asigno _myStructObject1 en eso.
Aquí el compilador .NET C # crea otra copia del objeto _myStructureObject1 y
asigna esa ubicación de memoria a la variable de MyStructure _myStructObject2.

Entonces, cualquier cambio que hagamos en _myStructObject1 nunca tendrá efecto en otra variable _myStructObject2 de tipo MyStructrue.
Es por eso que estamos diciendo que las estructuras son tipos de valor.

Entonces, la clase Base inmediata para la clase es Object y la clase Base inmediata para Structure es ValueType que hereda de Object.
Las clases admitirán una herencia, mientras que las estructuras no.

¿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 y parcial y no puede ser privado, protegido y protegido interno.

Hay 3 diferencias básicas entre estructura y clase

La primera memoria está reservada para la estructura en la memoria de la pila (que está cerca del lenguaje de programación) si la clase en la memoria de la pila está reservada solo para referencia y la memoria real está reservada en la memoria del montón.

2º - Por defecto, la estructura trata como pública si la clase trata como privada.

3Rd- no se puede reutilizar el código en la estructura, pero en clase podemos reutilizar el mismo código en muchas ocasiones llamado inhertence