Quais são as diferenças entre struct e classe em C ++?

Esta pergunta já foi feita no contexto de C # / .Net .

Agora eu gostaria de aprender as diferenças entre uma estrutura e uma classe em C ++. Por favor, discuta as diferenças técnicas e os motivos para escolher uma ou outra no design do OO.

Vou começar com uma diferença óbvia:

• Se você não especificar public:ou private:, os membros de uma estrutura serão públicos por padrão; os membros de uma classe são privados por padrão.

Tenho certeza de que existem outras diferenças nos cantos obscuros da especificação C ++.

Você esquece a complicada segunda diferença entre classes e estruturas.

Quoth o padrão (§11.2.2 em C ++ 98 a C ++ 11):

Na ausência de um acesso de especificador para uma classe base, público é assumido quando a classe derivada é declarado struct e privado é assumida quando a classe é declarada classe .

E apenas por uma questão de completude, a diferença mais conhecida entre classe e estrutura é definida em (11.2):

O membro de uma classe definida com a classe de palavra-chave é privado por padrão. Os membros de uma classe definida com as palavras-chave struct ou union são públicos por padrão.

Diferença adicional: a palavra-chave classpode ser usada para declarar parâmetros do modelo, enquanto a structpalavra - chave não pode ser usada.

Citando o FAQ do C ++ ,

[7.8] Qual é a diferença entre as palavras-chave struct e classe?

Os membros e as classes base de uma estrutura são públicos por padrão, enquanto na classe, eles são privados. Nota: você deve tornar suas classes base explicitamente públicas, privadas ou protegidas, em vez de confiar nos padrões.

Struct e classe são funcionalmente equivalentes.

OK, chega dessa conversa limpa e estridente. Emocionalmente, a maioria dos desenvolvedores faz uma forte distinção entre uma classe e uma estrutura. Uma estrutura simplesmente parece uma pilha aberta de bits com muito pouco em termos de encapsulamento ou funcionalidade. Uma classe se sente como um membro vivo e responsável da sociedade, com serviços inteligentes, uma forte barreira de encapsulamento e uma interface bem definida. Como essa é a conotação que a maioria das pessoas já tem, você provavelmente deve usar a palavra-chave struct se tiver uma classe que possui muito poucos métodos e dados públicos (essas coisas existem em sistemas bem projetados!), Mas, caso contrário, você provavelmente deve usar a classe palavra-chave

Vale lembrar as origens do C ++ e a compatibilidade com o C.

C tem estruturas, não tem conceito de encapsulamento, então tudo é público.

Ser público por padrão geralmente é considerado uma má idéia ao adotar uma abordagem orientada a objetos; portanto, ao criar uma forma de C que seja nativamente favorável ao OOP (você pode fazer OO em C, mas não vai ajudá-lo), esse foi o No C ++ (originalmente "C With Classes"), faz sentido tornar os membros privados por padrão.

Por outro lado, se o Stroustrup tivesse alterado a semântica structpara que seus membros fossem privados por padrão, ele teria uma compatibilidade quebrada (não é mais tão verdadeira quanto os padrões divergiam, mas todos os programas C válidos também eram programas C ++ válidos, que teve um grande efeito em dar suporte ao C ++).

Portanto, uma nova palavra-chave classfoi introduzida para ser exatamente como uma estrutura, mas privada por padrão.

Se o C ++ tivesse surgido do zero, sem histórico, provavelmente teria apenas uma dessas palavras-chave. Provavelmente também não teria causado o impacto que causou.

Em geral, as pessoas tendem a usar struct quando estão fazendo algo como como as estruturas são usadas em C; membros públicos, nenhum construtor (contanto que não esteja em uma união, você pode ter construtores em estruturas, assim como as classes, mas as pessoas tendem a não), nenhum método virtual etc. as pessoas que leem o código para instruir as máquinas (ou então ficaríamos com os opcodes de montagem e de VM brutos) é uma boa ideia ficar com isso.

Os membros da classe são privados por padrão. Os membros do Struct são públicos por padrão. Além disso, não há outras diferenças. Veja também esta pergunta .

De acordo com Stroustrup na linguagem de programação C ++ :

O estilo que você usa depende das circunstâncias e do gosto. Eu geralmente prefiro usar structpara classes que têm todos os dados públicos. Penso nessas classes como "tipos não muito adequados, apenas estruturas de dados".

Funcionalmente, não há outra diferença senão o público / privado

STRUCT é um tipo de Tipo de Dados Abstrato que divide um determinado pedaço de memória de acordo com a especificação da estrutura. As estruturas são particularmente úteis na serialização / desserialização de arquivos, pois a estrutura pode ser gravada no arquivo literalmente. (ou seja, obtenha um ponteiro para a estrutura, use a macro SIZE para calcular o número de bytes a serem copiados e mova os dados para dentro ou para fora da estrutura.)

As classes são um tipo diferente de tipo de dados abstratos que tentam garantir a ocultação de informações. Internamente, pode haver uma variedade de maquinações, métodos, variáveis ​​temporárias, variáveis ​​de estado. etc., todos usados ​​para apresentar uma API consistente para qualquer código que deseje usar a classe.

Com efeito, estruturas são sobre dados, classes são sobre código.

No entanto, você precisa entender que essas são apenas abstrações. É perfeitamente possível criar estruturas que se parecem muito com classes e classes que se parecem muito com estruturas. De fato, os primeiros compiladores C ++ eram meramente pré-compiladores que convertem o código C ++ em C. Portanto, essas abstrações são um benefício para o pensamento lógico, não necessariamente um ativo para o próprio computador.

Além do fato de que cada um é um tipo diferente de abstração, as Classes fornecem soluções para o quebra-cabeça de nomeação de código C. Como você não pode ter mais de uma função exposta com o mesmo nome, os desenvolvedores costumavam seguir um padrão de _ (). por exemplo, mathlibextreme_max (). Ao agrupar APIs em classes, funções semelhantes (aqui as chamamos de "métodos") podem ser agrupadas e protegidas da nomeação de métodos em outras classes. Isso permite que o programador organize melhor seu código e aumente sua reutilização. Em teoria, pelo menos.

1) Membros de uma classe são privados por padrão e membros de struct são públicos por padrão.

Por exemplo, o programa 1 falha na compilação e o programa 2 funciona bem.

// 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) Ao derivar uma estrutura de uma classe / estrutura, o especificador de acesso padrão para uma classe / estrutura base é público. E ao derivar uma classe, o especificador de acesso padrão é privado.

Por exemplo, o programa 3 falha na compilação e o programa 4 funciona bem.

// 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;
}

A única outra diferença é a herança padrão de classes e estruturas, que, sem surpresa, é privada e pública, respectivamente.

1. Os membros de uma estrutura são públicos por padrão, os membros da classe são privados por padrão.
2. A herança padrão para a Estrutura de outra estrutura ou classe é pública. A herança padrão para a classe de outra estrutura ou classe é 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;
}

Isso está no VS2005.

Não na especificação, não. A principal diferença está nas expectativas dos programadores quando eles leem seu código em 2 anos. estruturas são freqüentemente assumidas como POD. As estruturas também são usadas na metaprogramação de modelos quando você define um tipo para outros fins que não a definição de objetos.

Outra coisa a observar, se você atualizou um aplicativo herdado que possui estruturas para usar classes, pode encontrar o seguinte problema:

O código antigo possui estruturas, o código foi limpo e elas foram alteradas para classes. Uma função virtual ou duas foram adicionadas à nova classe atualizada.

Quando as funções virtuais estão nas classes, internamente, o compilador adicionará um ponteiro extra aos dados da classe para apontar para as funções.

Como isso quebraria o código legado antigo, se no código antigo em algum lugar a estrutura foi limpa usando o memfill para limpar tudo em zeros, isso também afetaria os dados extras do ponteiro.

1. O membro de uma classe definida com a palavra-chave classé privatepor padrão. Os membros de uma classe definida com as palavras-chave struct(ou union) são publicpor padrão.

2. Na ausência de um especificador de acesso para uma classe base, publicé assumido quando a classe derivada é declarada structe privateé assumido quando a classe é declarada class.

3. Você pode declarar um, enum classmas não um enum struct.

4. Você pode usar, template<class T>mas não template<struct T>.

Observe também que o padrão C ++ permite que você declare um tipo como a structe use-o classao declarar o tipo e vice-versa. Além disso, std::is_class<Y>::valueé truepara Y ser um structe a class, mas é falsepara um enum class.

A diferença entre classe structé uma diferença entre palavras-chave, não entre tipos de dados. Esses dois

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

ambos definem um tipo de classe. A diferença das palavras-chave neste contexto é o acesso padrão diferente:

• foo::xé público e foo_baseé herdado publicamente
• bar::xé privado e bar_baseé herdado em particular

Aqui está uma boa explicação: http://carcino.gen.nz/tech/cpp/struct_vs_class.php

Portanto, mais uma vez: em C ++, uma estrutura é idêntica a uma classe, exceto que os membros de uma estrutura têm visibilidade pública por padrão, mas os membros de uma classe têm visibilidade privada por padrão.

É apenas uma convenção. Estruturas podem ser criadas para armazenar dados simples, mas depois evoluem o tempo com a adição de funções-membro e construtores. Por outro lado, é incomum ver algo que não seja público: acesso em uma estrutura.

ISO IEC 14882-2003

9 aulas

§3

Uma estrutura é uma classe definida com a chave de classe struct ; seus membros e classes base (cláusula 10) são públicos por padrão (cláusula 11).

Outra diferença principal é quando se trata de modelos. Tanto quanto eu sei, você pode usar uma classe ao definir um modelo, mas NÃO uma estrutura.

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

As outras respostas mencionaram os padrões público / privado (mas observe que uma estrutura é uma classe é uma estrutura; elas não são dois itens diferentes, apenas duas maneiras de definir o mesmo item).

O que pode ser interessante notar (principalmente porque o solicitante provavelmente está usando o MSVC ++, pois menciona C ++ "não gerenciado") é que o Visual C ++ reclama em determinadas circunstâncias se uma classe é declarada com classe depois definida com struct(ou possivelmente o contrário) ), embora a norma diga que é perfeitamente legal.

• . Nas classes, todos os membros por padrão são privados, mas na estrutura os membros são públicos por padrão.

  1. Não há termo como construtor e destruidor para estruturas, mas para o compilador de classes cria o padrão se você não fornecer.

  2. O tamanho da estrutura vazia é 0 Bytes e o tamanho da classe vazia é 1 Byte O tipo de acesso padrão da estrutura é público. Uma estrutura normalmente deve ser usada para agrupar dados.

  O tipo de acesso padrão da classe é privado e o modo padrão de herança é privado. Uma classe deve ser usada para agrupar dados e métodos que operam nesses dados.

  Em resumo, a convenção é usar struct quando o objetivo é agrupar dados e usar classes quando exigirmos abstração de dados e, talvez, herança.

  No C ++, estruturas e classes são passadas por valor, a menos que seja explicitamente referenciado. Em outras línguas, classes e estruturas podem ter semântica distinta - ie. objetos (instâncias de classes) podem ser passados ​​por referência e estruturas podem ser passadas por valor. Nota: existem comentários associados a esta pergunta. Veja a página de discussão para adicionar à conversa.

Embora implícito em outras respostas, não é mencionado explicitamente - que as estruturas são compatíveis com C, dependendo do uso; classes não são.

Isso significa que, se você estiver escrevendo um cabeçalho que deseja ser compatível com C, não terá outra opção além de struct (que no mundo C não pode ter funções; mas pode ter ponteiros de função).

Você pode considerar isso para obter diretrizes sobre quando escolher uma estrutura ou classe, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .

√ CONSIDERAM definir uma estrutura em vez de uma classe se as instâncias do tipo são pequenas e geralmente têm vida curta ou são incorporadas em outros objetos.

X EVITE definir uma estrutura, a menos que o tipo tenha todas as seguintes características:

Representa logicamente um valor único, semelhante aos tipos primitivos (int, double, etc.).

Tem um tamanho de instância com menos de 16 bytes.

É imutável.

Não precisará ser embalado com freqüência.

A classe é significativa apenas no contexto da engenharia de software. No contexto de estruturas e algoritmos de dados, classe e estrutura não são tão diferentes. Não há nenhuma regra restrita que o membro da classe deva ser referenciado.

Ao desenvolver um projeto grande com toneladas de pessoas sem classe, você pode finalmente obter um código acoplado complicado, porque todos usam as funções e os dados que desejam. A classe fornece controles de permissão e inerentes para aprimorar a dissociação e a reutilização de códigos.

Se você ler alguns princípios de engenharia de software, verá que a maioria dos padrões não pode ser implementada facilmente sem aula. por exemplo: http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

BTW, Quando uma estrutura aloca uma restrição de memória e inclui várias variáveis, as variáveis ​​de tipo de valor indicam que os valores estão incorporados no local em que a estrutura está alocada. Por outro lado, os valores da variável do tipo de referência são externos e são referenciados por um ponteiro que também é incorporado no local onde struct está alocado.

A diferença entre palavras-chave struct e class em C ++ é que, quando não há especificador específico em determinado tipo de dados compostos, por padrão struct ou union são as palavras-chave públicas que apenas consideram a ocultação de dados, mas class é a palavra-chave privada que considera a ocultação do programa. códigos ou dados. Sempre alguns programadores usam struct para dados e classe por causa de código. Para mais informações, entre em contato com outras fontes.

De todos esses fatores, pode-se concluir que o conceito de Classe é altamente adequado para representar objetos do mundo real, em vez de "Estruturas" .Em grande parte porque os conceitos de POO usados ​​na classe são altamente práticos na explicação de cenários do mundo real, portanto, mais fáceis de mesclá-los à realidade. Por exemplo, a herança padrão é pública para estruturas, mas se aplicarmos essa regra ao mundo real, isso é ridículo. Mas em uma classe a herança padrão é privada, o que é mais realista.

De qualquer forma, o que preciso justificar é que Classe é um conceito aplicável no mundo real muito mais amplo, enquanto que Estrutura é um conceito primitivo com organização interna ruim (Eventhough struct segue os conceitos de OOP, eles têm um significado ruim)

A principal diferença entre a estrutura e a palavra-chave class em ops é que, nenhuma declaração de membro pública e privada presente na estrutura. E o membro de dados e a função de membro podem ser definidos como público, privado e também protegido.

** UPDATE: ** Por favor, ignore esta resposta. Não considerei a possibilidade de que, para o struct, o valor não tivesse sido inicializado, mas por acaso fosse 0. Não há uma diferença de inicialização entre o struct e a classe.

Estou vendo outra diferente entre estruturas e classes relacionadas à inicialização padrão.

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();
}

Execute esse código e examine o myTester. Você verá que para m_Foo, a estrutura m_Foo.a foi inicializada como 0, mas para m_Bar, a classe m_Bar.a não foi inicializada. Portanto, parece haver uma diferença no que o construtor padrão faz para struct vs. classe. Estou vendo isso com o Visual Studio.

A principal diferença entre struct e classe é que, em struct, você pode declarar apenas variáveis ​​de dados de diferentes tipos de dados, enquanto na classe você pode declarar variáveis ​​de dados, funções-membro e, portanto, pode manipular variáveis ​​de dados por meio de funções.

-> outra coisa útil que eu acho na classe versus estrutura é que, ao implementar arquivos em um programa, se você deseja fazer algumas operações de uma estrutura repetidas vezes a cada novo conjunto de operações, você precisa criar uma função separada e precisa passa o objeto de struct depois de lê-lo do arquivo para fazer algumas operações nele. Enquanto estiver na aula, se você criar uma função que faça algumas operações com os dados necessários todas as vezes ... é fácil, basta ler o objeto do arquivo e chamar a função

Mas depende do programador de que maneira ele / ela considera adequado ... de acordo com mim, eu prefiro a aula toda vez que suporta OOPs e é por isso que ela é implementada em quase todas as linguagens e é o recurso maravilhoso de toda a programação em tempo; )

E sim, a diferença mais inesquecível que esqueci de mencionar é que a classe suporta ocultação de dados e também suporta operações que são executadas em tipos de dados incorporados, enquanto o struct não!

Eu encontrei outra diferença. se você não definir um construtor em uma classe, o compilador definirá um. mas em uma estrutura, se você não definir um construtor, o compilador também não definirá um construtor. portanto, em alguns casos, na verdade, não precisamos de um construtor, struct é uma escolha melhor (dica de desempenho). e desculpe pelo meu inglês ruim.

Classes são tipos de referência e estruturas são tipos de valores.
Quando digo que Classes são tipos de referência,
basicamente elas conterão o endereço de uma variável de instância.

Por exemplo:

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

No método principal,
posso criar uma instância dessa classe usando o novo operador que aloca memória para essa classe
e armazena o endereço base na variável do tipo MyClass (_myClassObject2).

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

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

No programa acima, MyClass _myClassObject2 = _myClassObject1; A instrução indica que ambas as variáveis ​​do tipo MyClass

1. myClassObject1
2. myClassObject2

e apontará para o mesmo local de memória.
Basicamente, atribui o mesmo local de memória a outra variável do mesmo tipo.

Portanto, se qualquer alteração que fizermos em qualquer um dos objetos, digite MyClass, terá efeito sobre outro,
pois ambos apontam para o mesmo local de memória.

"_myClassObject1.DataMember = 10;" nessa linha, os membros de dados do objeto conterão o valor 10.
"_myClassObject2.DataMember = 20;" nessa linha, o membro de dados do objeto conterá o valor de 20.
Eventualmente, estamos acessando de um objeto por meio de ponteiros.

Diferentemente das classes, as estruturas são tipos de valor. Por exemplo:

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;
}

No programa acima,
instanciar o objeto do tipo MyStructure usando o novo operador e
armazenar o endereço na variável _myStructObject do tipo MyStructure e
atribuir o valor 10 ao membro de dados da estrutura usando "_myStructObject1.DataMember = 10".

Na próxima linha,
estou declarando outra variável _myStructObject2 do tipo MyStructure e atribuindo _myStructObject1 a isso.
Aqui, o compilador .NET C # cria outra cópia do objeto _myStructureObject1 e
atribui esse local de memória à variável MyStructure _myStructObject2.

Portanto, qualquer alteração que fizermos em _myStructObject1 nunca terá efeito em outra variável _myStructObject2 do tipo MyStructrue.
É por isso que estamos dizendo que Estruturas são tipos de valor.

Portanto, a classe Base imediata para a classe é Object e a classe Base imediata para Structure é ValueType que herda de Object.
As classes apoiarão uma herança, enquanto as estruturas não.

Como estamos dizendo isso?
E qual é a razão por trás disso?
A resposta é Classes.

Pode ser abstrato, selado, estático e parcial e não pode ser Privado, Protegido e protegido interno.

Existem 3 diferenças básicas entre estrutura e classe

A memória 1St- é reservada para a estrutura na memória da pilha (que fica próxima à linguagem de programação), independentemente da classe na memória da pilha ser reservada apenas para armazenamento e a memória real ser reservada na memória de pilha.

2º - Por padrão, a estrutura trata como público se a classe é tratada como privada.

3Rd - não é possível reutilizar o código na estrutura, mas na classe podemos reutilizar o mesmo código em muitas vezes chamado de herança