Introducción comparativa a estructura y unión en C++
En C++, tanto struct como union son palabras clave que se utilizan para definir tipos de datos personalizados, pero sus funciones son ligeramente diferentes.
Primero comprenda sus conceptos básicos:
Estructura (estructura): Struct es un tipo de datos definido por el usuario que puede contener múltiples variables miembro de diferentes tipos y funciones. Estas variables miembro son independientes en la estructura y ocupan espacio de memoria independiente, respectivamente. Se puede acceder a los miembros de la estructura a través de derechos de acceso específicos (público, privado, protegido).
Unión (union): unión también es un tipo de datos definido por el usuario, pero no puede contener funciones. Sus miembros comparten el mismo espacio de memoria. Esto significa que todas las variables miembro de la unión están ubicadas en la misma área de memoria y el tamaño del espacio de memoria está determinado por la variable miembro más larga.
Si necesita definir un tipo de datos que contenga varios miembros con diferentes tipos de datos, puede utilizar la palabra clave struct. Por ejemplo, se puede definir un tipo de datos de información del estudiante, incluido el número del estudiante, el nombre, las calificaciones y otros miembros, usando struct:
estructura Estudiante {
identificación interna;
nombre de cadena;
grado flotante;
};
Los tipos definidos mediante struct son muy intuitivos y fáciles de operar y no requieren demasiadas consideraciones de seguridad.
Si necesita definir un tipo de datos que pueda compartir memoria, puede utilizar la palabra clave union. Sólo uno de los diferentes miembros de la unión puede ser válido al mismo tiempo porque comparten la misma memoria. Por ejemplo, definir un tipo de datos que pueda almacenar datos int, float y char al mismo tiempo se puede definir mediante unión:
datos de unión {
ent i;
flotador f;
cadena char[20];
};
El tipo definido con la palabra clave union es muy peligroso porque sus miembros comparten la misma memoria, si se usa incorrectamente es probable que ocurran problemas como confusión de datos y se debe prestar especial atención a la seguridad.
En C++, los miembros de struct y union son públicos de forma predeterminada, pero los derechos de acceso se pueden configurar según sea necesario, como configurar ciertos miembros como privados o protegidos. Las configuraciones de permisos de acceso específicos se implementan agregando modificadores de acceso a las declaraciones de los miembros.
La estructura puede tener miembros funcionales, la unión no puede contener miembros funcionales.
Por lo tanto, el uso de struct y union aún depende de la situación específica y la elección debe basarse en las necesidades reales del problema.
Para struct (estructura), sus miembros pueden ser de los siguientes tipos:
Miembro de datos: puede ser cualquier tipo de datos legal de C++, incluidos tipos de datos básicos (como enteros, coma flotante, booleanos), tipos de datos personalizados (como clases, estructuras, enumeraciones), etc.
Miembro de función (función miembro): la función definida dentro de la estructura se puede utilizar para manipular los datos de la estructura. Los miembros de la función pueden acceder a miembros privados y protegidos de la estructura.
Miembros estáticos: pueden ser miembros de datos estáticos o miembros de funciones estáticas. Los miembros de datos estáticos son datos compartidos por objetos de tipo estructura y los miembros de funciones estáticas son funciones que no dependen de objetos específicos.
Un ejemplo de struct (estructura) es el siguiente:
#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;
}
Un sindicato puede contener miembros de los siguientes tipos:
Miembro de datos: puede ser cualquier tipo de datos legal de C++, incluidos tipos de datos básicos (como enteros, coma flotante, booleanos), tipos de datos personalizados (como clases, estructuras, enumeraciones), etc. Tenga en cuenta que los miembros de datos de la unión comparten espacio de almacenamiento y solo pueden almacenar el valor de un miembro.
Estructuras o uniones anidadas: las estructuras o uniones anidadas se pueden definir dentro de las uniones.
Un ejemplo de unión es el siguiente:
#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;
}