Existe uma diferença de desempenho entre struct e classe em c ++?

Não. As classes C ++ são estruturas que começam com visibilidade privada em vez de pública.

Em outros idiomas, eles são muito diferentes: C # e D usam classe para definir tipos de referência coletados por lixo e estruturas para definir tipos de valor. Novamente, isso não está em C ++.

No C ++, classe e estrutura podem estender outras classes ou estruturas e se comportar exatamente da mesma maneira. A única diferença que você pode ver é na manipulação de nomes, e mesmo isso não é por especificação: isso acontece apenas em alguns compiladores (MSVC), mas ainda não causa diferença de comportamento.

A2A. Não. Eles são praticamente idênticos, exceto pela acessibilidade padrão dos membros: struct -> public, class -> private. Pode haver alguns problemas de compatibilidade C ... não tenho certeza se o código C pode manipular uma classe (mesmo com apenas membros de dados públicos) tratando-a como uma estrutura ou não. Dito isso, não há diferenças de desempenho e nenhuma outra diferença, exceto relacionada à acessibilidade padrão, se o seu código não for interoperável com o código C.

É realmente apenas uma diferença de tipo de conveniência / preferência pessoal.

Existe uma diferença de desempenho entre struct e classe em C ++?

Não.

Em C ++, uma definição de estrutura e uma definição de classe são absolutamente idênticas em todos os aspectos, exceto um:

  • O especificador de acesso padrão de uma estrutura é public
  • O especificador de acesso padrão de uma classe é privado

Fora isso, uma estrutura e uma classe resultarão em comportamentos estáticos e de tempo de execução idênticos.

Não no binário compilado.

Qualquer desempenho de um sobre o outro está na qualidade do código-fonte e do modelo de software.

O C ++ mantém os dados da instância e os dados da classe separados, tanto para a classe quanto para a estrutura. Assim, uma classe e uma estrutura terão a mesma representação dos dados da instância, todas as coisas iguais. As “proteções” impostas pelo compilador de origem e algum suporte de vinculação existem para “proteger” o modelo de objeto e aplicar a higiene adequada dos dados, não para fornecer “segurança” ou alguma “rede de segurança” no código em execução.

As estruturas podem até ter métodos públicos, protegidos e privados, se você quiser (por que?), Mas isso geralmente não é uma coisa. O modelo de acesso privado existe para incentivar o encapsulamento e resolver alguns problemas com a interação do objeto da maneira "correta", de acordo com os textos acadêmicos, e de acordo com o pensamento atual sobre como fazer a Orientação a Objetos no software.

É interessante notar que não há nada que uma classe possa fazer que uma estrutura não possa fazer, mas o inverso não é verdadeiro. Privado e Protegido são restrições apenas para a fonte e, se você achar que elas estão atrapalhando, poderá contorná-las ou tornar público tudo e rasgá-lo o quanto quiser.

C ++ não é uma linguagem de 'ensino', como Java. Não se preocupa demais em impedir que codificadores executem códigos de maneiras perigosas. "Perigoso" significa coisas que podem quebrar a integridade dos dados ou do objeto ou do tempo de execução e prejudicá-los muito, se você errar. Ensinar idiomas e textos faz todo o possível para mimar os iniciantes e mantê-los no "caminho certo", porque é fácil explodir programas quando você não está familiarizado com todos os truques do comércio e dos procedimentos padrão. Isso é uma coisa relativamente nova, no entanto. Nos velhos tempos de C e Pascal e Lisp, os alunos eram jogados na cabeça primeiro e isso era bom, porque a maioria nunca seria boa nessas coisas de codificação - deixe-os descobrir cedo e pagar a fiança, serão muito mais felizes em a longo prazo.

Oh, eu fiquei um pouco fora do tópico lá ...

Estruturas e classes são 100% compatíveis. De fato, muitas classes que fazem interface com o código C podem usar os membros de dados diretamente nas funções C com uma conversão de tipo simples (ou nenhuma alteração).

  1. #incluir #incluir #incluir #incluir struct stat {dev_t st_dev; // ID do dispositivo que contém o arquivo ino_t st_ino; // Inode mode_t st_mode; // Tipo e modo de arquivo nlink_t st_nlink; // Número de links físicos uid_t st_uid; // ID do usuário do proprietário gid_t st_gid; // ID do grupo do proprietário dev_t st_rdev; // ID do dispositivo (se arquivo especial) off_t st_size; // Tamanho total, em bytes blksize_t st_blksize; // Tamanho do bloco para E / S blkcnt_t st_blocks; // Número de blocos 512B / * Desde o Linux 2.6, o kernel suporta precisão de nanossegundos para os seguintes campos de registro de data e hora. Para obter detalhes antes do Linux 2.6, consulte NOTAS. * / struct timespec st_atim; // Hora do último acesso struct timespec st_mtim; // Hora da última modificação struct timespec st_ctim; // Hora da última alteração de status #define st_atime st_atim.tv_sec / * Compatibilidade com versões anteriores * / #define st_mtime st_mtim.tv_sec #define st_ctime st_ctim.tv_sec}; ** / # include #incluir #incluir ; int main (int argc, char * argv []) {std: vetor args (argv + 1, argv + (argc-1)); if (args.length () == 0) {std :: cerr << "status de uso "<<" \ n "; return (EXIT_FAILURE);} for (auto f: args) {struct stat fileInfo; // c ++ cria struct com valores padrão // recursivamente (subestruturas) char * fname = f.c_str () ; // chama stat () diretamente se (stat (fname, & fileInfo)! = 0) {std :: cerr << "Erro:" << strerror (errno) << '\ n'; return (EXIT_FAILURE);} std :: cout << "Tipo::"; if ((fileInfo.st_mode & S_IFMT) == S_IFDIR) std :: cout << "Diretório \ n"; else std :: cout << "Arquivo \ n"; std :: cout << "Tamanho:" << fileInfo.st_size << '\ n'; // bytes std :: cout << "Dispositivo:" << (char) (fileInfo.st_dev + 'A') < <'\ n'; // Dev std :: cout << "Criado:" << std :: ctime (& fileInfo.st_ctime); // ctime std :: cout << "Modificado:" << std :: ctime (& fileInfo.st_mtime); // hora da modificação // ...} // para f} // main

Não. Não em C ++, pelo menos.

o

A diferença entre uma estrutura e uma classe em C ++ é o acesso padrão aos membros. Em uma estrutura, o acesso padrão é público (para compatibilidade com estruturas C). Em uma classe, o acesso padrão é privado. Do ponto de vista puramente técnico, os dois são completamente intercambiáveis ​​além dessa única diferença.

Internamente, a implementação do compilador pode usar esquemas de nomes diferentes entre struct e classe, mas isso dependeria do compilador e não teria impacto no desempenho.

No entanto, para tornar mais clara a intenção do seu código para o leitor / mantenedor, você deve usar struct apenas para dados antigos simples (POD), da maneira como são usados ​​em C, e usar classe para qualquer coisa que não seja POD (ou seja, qualquer coisa com funções membro, incluindo construtores, destruidor etc.).

No

de outros

linguagens que suportam estrutura e classe, pode haver

principal

diferenças entre os dois. Por exemplo, em C #, uma estrutura se comporta

muito

diferentemente de uma classe, e a diferença pode ter implicações significativas no desempenho (por exemplo, boxe e unboxing).