Introdução comparativa à estrutura e união em C++

Em C++, struct e union são palavras-chave usadas para definir tipos de dados personalizados, mas suas funções são ligeiramente diferentes.

Primeiro entenda seus conceitos básicos:

Struct (estrutura): struct é um tipo de dados definido pelo usuário que pode conter várias variáveis de membro de diferentes tipos e pode conter funções. Essas variáveis-membro são independentes na estrutura e ocupam espaço de memória independente. Os membros da estrutura podem ter acesso controlado por meio de direitos de acesso específicos (público, privado, protegido).

União: União também é um tipo de dados definido pelo usuário, mas não pode conter funções. Seus membros compartilham o mesmo espaço de memória. Isso significa que todas as variáveis-membro na união estão localizadas na mesma área de memória e o tamanho do espaço de memória é determinado pela variável-membro mais longa.

Se precisar definir um tipo de dados que contenha vários membros com diferentes tipos de dados, você poderá usar a palavra-chave struct. Por exemplo, um tipo de dados de informações do aluno, incluindo número do aluno, nome, notas e outros membros, pode ser definido usando struct:

estrutura Aluno {

identificação interna;

nome da sequência;

grau flutuante;

};

Os tipos definidos usando struct são muito intuitivos e fáceis de operar e não exigem muitas considerações de segurança.

Se precisar definir um tipo de dados que possa compartilhar memória, você poderá usar a palavra-chave union. Apenas um dos diferentes membros do sindicato pode ser válido ao mesmo tempo porque partilham a mesma memória. Por exemplo, definir um tipo de dados que pode armazenar dados int, float e char ao mesmo tempo pode ser definido usando união:

dados sindicais {

int eu;

flutuar f;

charstr[20];

};

Os tipos definidos usando a palavra-chave union são altamente perigosos porque seus membros compartilham a mesma memória. Se usados incorretamente, podem ocorrer problemas como confusão de dados. Atenção especial deve ser dada à segurança.

Em C++, os membros de struct e union são públicos por padrão, mas as permissões de acesso podem ser definidas conforme necessário, como definir determinados membros como privados ou protegidos. Configurações específicas de permissão de acesso são obtidas adicionando modificadores de acesso ao declarar membros.

A estrutura pode ter membros de função, a união não pode conter membros de função.

Portanto, o uso de struct e union ainda depende da situação específica, e a escolha precisa ser baseada nas reais necessidades do problema.

Para struct (estrutura), seus membros podem ser dos seguintes tipos:

Membro de função (função de membro): Uma função definida dentro de uma estrutura que pode ser usada para manipular os dados da estrutura. Os membros da função podem acessar os membros privados e protegidos da estrutura.

Membros estáticos: podem ser membros de dados estáticos ou membros de função estática. Membros de dados estáticos são dados compartilhados por objetos do tipo struct e membros de funções estáticas são funções que não dependem de objetos específicos.

Um exemplo de struct (estrutura) é o seguinte:

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;

    void print() {
        cout << "Point: (" << x << ", " << y << ")" << endl;
    }

    static int count;
    static void incrementCount() {
        count++;
    }
};

int Point::count = 0;

int main() {
    Point p1 = {3, 4};
    p1.print();  // 输出: Point: (3, 4)

    Point::incrementCount();
    cout << "Point count: " << Point::count << endl;  // 输出: Point count: 1

    return 0;
}

Uma união pode conter membros dos seguintes tipos:

Membros de dados: podem ser qualquer tipo de dados C++ legal, incluindo tipos de dados básicos (como inteiro, ponto flutuante, booleano), tipos de dados personalizados (como classes, estruturas, enumerações), etc. Observe que os membros de dados da união compartilham espaço de armazenamento e só podem armazenar o valor de um membro.

Estruturas ou uniões aninhadas: estruturas ou uniões aninhadas podem ser definidas dentro de uniões.

Um exemplo de união é o seguinte:

#include <iostream>
using namespace std;

union Data {
    int i;
    float f;
    char c;
};

struct Employee {
    string name;
    union {
        int age;
        float salary;
    };
};

int main() {
    Data d;
    d.i = 42;
    cout << "Data value: " << d.i << endl;  // 输出: Data value: 42

    Employee e;
    e.name = "John";
    e.age = 30;
    cout << "Employee: " << e.name << ", " << e.age << " years old" << endl; // 输出: Employee: John, 30 years old
    
    e.salary = 5000.0;
    cout << "Employee: " << e.name << ", salary: " << e.salary << endl; // 输出: Employee: John, salary: 5000

    return 0;
}

Introdução comparativa à estrutura e união em C++

Introdução comparativa à estrutura e união em C++

Acho que você gosta