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

441

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 ++.

palm3D
fuente
66
Este enlace resume bien las diferencias.
sjsam
1
¿Por qué todas las personas usan struct para construir un árbol entonces? Porque parece que la diferencia no es tanto. Por cierto, ese es un gran sitio web. @ Sjsam
JW.ZG
1
¿Busca la diferencia entre structC y C ++? Vea aquí .
Marc.2377
@ JW.ZG ¡No "todas" las personas lo hacen! Aquellos que hacen eso simplemente prefieren o no se dan cuenta de lo que structsignifica en C ++. ;) Pero no hay razón para que no puedas usar la classpalabra clave.
Carreras de ligereza en órbita el

Respuestas:

466

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í.

Assaf Lavie
fuente
22
Esa no es realmente una segunda diferencia, es solo que la pregunta establece la diferencia de manera incompleta. Todos los subobjetos son privados de forma predeterminada cuando se utiliza class, public de forma predeterminada con struct, y ambos definen un tipo de clase.
Ben Voigt
10
Creo que te perdiste el punto, Ben. Es la herencia pública para las estructuras y privada para las clases. Esa es una distinción muy importante y completamente ajena al acceso real de los miembros. Por ejemplo, el lenguaje podría haberlo definido de otra manera, por ejemplo, ambos se heredan públicamente de forma predeterminada, y obtendría implicaciones muy diferentes.
Assaf Lavie
104
En realidad, la verdadera diferencia difícil entre structy classes que este último se puede usar en lugar de a typenamepara declarar un parámetro de plantilla, mientras que el primero no. :)
sbi
21
@MrUniverse: Esto es completamente incorrecto. (Hay una escuela que usa esto para una convención, pero no se aplica de manera sintáctica.)
sbi
3
@sbi "la verdadera diferencia difícil entre estructura y clase" - Lindo, pero la pregunta es sobre la diferencia entre una estructura y una clase, no sobre las diferencias en el lugar donde se pueden usar las palabras clave.
Jim Balter
161

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.

Robᵩ
fuente
123

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.

Jon Hanna
fuente
Probablemente también valga la pena señalar que probablemente fue más fácil hacer que las clases y las estructuras funcionen igual bajo el capó, que hacer que sean fundamentalmente diferentes. En retrospectiva, podría haber algún beneficio, por ejemplo, especificar que cualquier cosa declarada como una estructura debe ser un PODS (es decir, prohibir que las estructuras tengan miembros virtuales, constructores o destructores predeterminados no triviales, etc.) pero tal cosa no tiene conocimiento. alguna vez ha sido requerido por cualquier estándar C ++ ni implementación.
supercat
1
@supercat el hecho de que era un lenguaje OO en el que un amplio repertorio de programas escritos en un lenguaje no OO eran programas válidos, trajo el concepto a primer plano, y parece surgir más allí que en lenguajes más puramente OO (y, por supuesto, está realmente definido en el estándar). La historia de principios de C ++ definitivamente explica mucho al respecto. "El diseño y la evolución de C ++" de Stroustrup es una lectura interesante.
Jon Hanna
1
Percibo una guerra religiosa entre las personas que sienten que todo lo que no es "oop-ish" debería serlo, y aquellos que piensan que la OOP debería considerarse como una herramienta, pero no como la herramienta. C ++ ciertamente parece adoptar la última filosofía, pero realmente no sé mucho sobre lenguajes antes. Mi propia filosofía es que cuando uno quiere un objeto debe usar un objeto, y cuando quiere una agregación de variables relacionadas pero independientes, debe usar eso. C ++ no hace distinción sintáctica entre ese tipo de cosas, y .NET intenta desdibujar esa distinción, pero lo poco que sé de D ...
supercat
1
... sugiere que lo reconoce más que C ++ o .NET. Las agregaciones de variables no son exactamente OOPish, pero eso no significa que no deberían emplearse cuando son útiles .
supercat
3
No estoy de acuerdo con "C tiene estructuras, no tiene un concepto de encapsulación, por lo que todo es público". Puede ocultar una definición de structdentro de un *.carchivo y dejar que otras unidades de traducción solo lo usen con un puntero. Por lo tanto, tiene una encapsulación aún más fuerte, porque otras unidades de traducción ni siquiera saben lo que hay dentro struct.
12431234123412341234123
32

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 .

Kasprzol
fuente
15
No solo los miembros, sino todos los accesos, incluida la herencia.
Nemanja Trifunovic
44
Bueno, yo diría que la otra diferencia es la semántica. Estructura para muchas personas les hace pensar "estructura de datos" como un sobrante de C.
Kris Kumler
3
@KrisKumler: Esas no son "semánticas"; Son sentimientos personales. Ambos structy classdeclaran una clase con semántica idéntica (a pesar de la interpretación parse-sabia del cuerpo de definición).
Carreras de ligereza en órbita el
28

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

crashmstr
fuente
32
¿Qué diferencia? Por favor explique.
crashmstr
10

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.

64BitBob
fuente
1
Esto es lo más obvio acerca de las estructuras y clases. "Las estructuras son sobre datos, las clases son sobre código" pueden reformularse como "las estructuras son sobre datos, las clases son sobre datos, la seguridad y las operaciones realizadas sobre estos datos"
Arun Aravind
3
No es posible crear una estructura en C ++. Solo es posible crear una clase usando la structpalabra clave heredada .
ligereza corre en órbita el
1
Esta respuesta no parece ser sobre C ++. En C ++, structdeclara clases (incluyendo public/ private/ protected, herencia, etc.).
melpomene
¿Cómo son las estructuras abstractas? Escribir estructuras en bruto en un archivo está lleno de problemas incluso en C (los problemas habituales incluyen relleno, endianness, diferentes tamaños de palabras, etc.). ¿De qué SIZEmacro estás hablando?
melpomene
10

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;
}
Suraj K Thomas
fuente
He eliminado los ejemplos de código 3-7 según lo mencionado por los expertos
Suraj K Thomas
8

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

Skizz
fuente
5
  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.

melpomene
fuente
_tmainno es estándar C ++.
melpomene
4

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.

MSalters
fuente
4

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.

KPexEA
fuente
1
El código que usa memfill para borrar una estructura probablemente tenga otros hábitos ofensivos. Ve con precaución.
David Thornley, el
@DavidThornley: El uso de un relleno de cero para borrar o inicializar una estructura de datos es estándar en C. En un proyecto de lenguaje mixto, no se puede esperar que el código en la parte C se evite calloca favor new. Todo lo que se puede hacer es tratar de asegurarse de que cualquier estructura utilizada por la parte C del código sea de hecho PODS.
supercat
4
  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.

Betsabé
fuente
respuesta agradable, aunque me falta un inconfundible clara 0) la diferencia entre structy classen C ++ es una diferencia entre las palabras clave, no entre tipos de datos (o alguna alternativa mejor;)
IDCLEV 463 035 818
@ formerlyknownas_463035818: ¿Pero no crees que std::is_class<Y>::valuecubre eso?
Betsabé
sí, pensé que podría ser más prominente, porque ese es el malentendido común y una vez que eso está fuera del camino, el resto son solo corolarios.
idclev 463035818
No importa, su respuesta es perfecta como es, escribí otro, herido doesnt tener uno más
IDCLEV 463035818
4

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
idclev 463035818
fuente
2

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.

Nutario
fuente
2

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.

finnw
fuente
2

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).

Gregory Pakosz
fuente
2

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
Stefan Popescu
fuente
1
Si tiene la intención de enfatizar que las estructuras no pueden usarse como tipos generalizados, entonces está equivocado. Y structno está permitido allí solo por convención (mejor decir que es una classpalabra clave que se usa en un sentido diferente aquí, vea Usar 'clase' o 'tipo de nombre' para los parámetros de la plantilla ).
dma_k
La palabra clave no está permitida allí, pero puede pasar en una clase que definió structmuy bien. Simplemente inténtalo. struct T{}; template <typename T> void foo() {} foo<T>();
Carreras de ligereza en órbita
1

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.

ymett
fuente
Sé que es un comentario muy tardío, pero tenga en cuenta que la advertencia antes mencionada no carece de mérito, ya que el ABI de Windows manipula las estructuras y las clases de manera diferente y, por lo tanto, la mezcla (hacia adelante) de declaraciones de clase y estructura puede conducir a problemas de vinculación difíciles de comprender.
MFH
1
  • . 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.

yshivakathik
fuente
3
"2. El tamaño de la estructura vacía es de 0 bytes, ya que el tamaño de la clase vacía es de 1 byte". Falso. Acabo de probar con g++. Quizás esté pensando en la optimización de la base vacía, pero eso también se aplica a ambos.
cdunn2001
1
No es verdad. En C ++ el tamaño de una estructura vacía es 1. En C no se permite una estructura vacía. GCC permite estructuras vacías en C como una extensión del compilador y dicha estructura tiene un tamaño 0.
Johan Råde
Esta respuesta es incorrecta. Además del tamaño, la parte constructor / destructor también es inexacta: las estructuras pueden tener constructores y destructores muy bien. De hecho, structcrea clases completas en C ++.
Melpomene
1

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).

UKMonkey
fuente
-1

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.

Kiriloff
fuente
Eso se trata de .NET / C #, no de C ++.
Melpomene
-2

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.

nieve
fuente
Esta respuesta no parece ser sobre C ++. En C ++, structdeclara clases (incluidos controles de permisos, herencia, etc.).
melpomene
-3

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.

MOBITI MAHENGE
fuente
OP ya mencionó que los structmiembros son públicos por defecto, y la respuesta aceptada de 2009 menciona la herencia. ¿Por qué escribir otra respuesta que no agrega información nueva 4 años después?
melpomene
-3

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)

Wageesha
fuente
1
¿Cómo es la herencia privada "más realista"? La mayoría de los lenguajes de programación ni siquiera tienen el concepto de herencia privada.
Melpomene
-3

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.

Tushar Bobade
fuente
Esta respuesta no parece ser sobre C ++. En C ++, structdeclara clases (incluyendo public/ private/ protected, herencia, etc.).
melpomene
-3

** 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.

Eric Hill
fuente
1
¿Cómo determinó que m_Foo.ase inicializó? ¿Qué pasa si no fue inicializado y resultó ser 0?
melpomene
Uhhh, no lo hice. Culpa mía. Esto no es una diferencia entre struct y class. Las características de inicialización son las mismas.
Eric Hill
-4

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.

Yug Rawal
fuente
1
En C ++ structpuede tener funciones miembro
chtz
@chtz Gracias ... conocí esta característica hace un momento ... muchas gracias ... soy solo un principiante, no tan experto como ustedes, así que en el futuro también necesito consejos de ustedes :-)
Yug Rawal
y, de hecho, la función miembro debe ser entendida en su significado más amplio. structpuede tener constructores, funciones miembro y distructor (posiblemente virtual, posiblemente privado, protegido o público). Pueden heredar y ser heredados. así que en realidad ... todo lo que una clase puede tener. Una convención típica es declarar con struct lo que habría declarado como struct en C, y como clase si declaramos variables privadas y protegidas, funciones virtuales, ctor y dtor, y así sucesivamente. Pero es solo una convención, no aplicada por el lenguaje
Gian Paolo
-5

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.

Ali
fuente
44
Esto no es verdad. No hay diferencia entre una clase definida con la structpalabra clave y una clase definida con la classpalabra clave a este respecto.
ymett
cuando uso una estructura sin un constructor, obtengo una mejor velocidad que una clase sin un constructor.
Ali
@ Ali No, no lo haces.
Carreras de ligereza en órbita el
-5

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.

Abhishek Sharma
fuente
44
Creo que esto está tratando de responder la pregunta para c #? La pregunta es sobre c ++, y eso hace que esta respuesta sea inexacta, ¿verdad?
smw
@smw absolutamente, ha escrito su código de muestra en C # y vine aquí para verificar que no haya una diferencia en el paso de parámetros entre C ++ structy class. Nadie aquí lo ha mencionado, ni toda la web. Así que tampoco creo que esto se aplique a C ++.
John
Esto ni siquiera es un código C # válido: las palabras clave son todas incorrectas. "Público", "Estático", "Int" y "Clase" no deben escribirse en mayúscula y deben ser "estructura", no "Estructura". La descripción es principalmente precisa para C # (aunque las estructuras aún pueden heredar interfaces, pero no otras estructuras), pero no responde la pregunta ya que se trataba de C ++ ...
Darrel Hoffman
2
Esta respuesta es una completa tontería. Utiliza una extraña mezcla de Visual Basic y C # para sus ejemplos de código, y todo "Las clases son tipos de referencia y las estructuras son tipos de valores" ... solo se aplica a .NET (es decir, C #) no a C ++. Estás en la habitación equivocada, amigo. Aquí es donde perteneces: stackoverflow.com/questions/13049
TheFlash
Pero esta respuesta indica que lo mismo es válido para C (++), que las estructuras se usan como tipos de valor. int a = 3; int b = a;y similarMyStruct a=MyStruct("data"); MyStruct b = a;
luckydonald
-8

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

Naveen
fuente
2
Las estructuras de C ++ admiten herencia y métodos abstractos. Estructura y clase se asignan de la misma manera. La asignación de clases en el montón incluso si no se instancian con un "nuevo" no tiene sentido para los sistemas integrados.
JCMS
2
# 1 también está mal. La pila se usa cuando declaras algo de ese tipo como una variable local, y el montón se usa cuando usas el operador "nuevo".
Score_Under