estructura c ++ común

Estructura

1. Defina el tipo de estructura

La estructura permite combinar diferentes tipos de elementos de datos para formar un nuevo tipo de datos. Su formulario de declaración es:

struct 结构体类型名 {
	成员列表
};

La declaración de tipo de estructura generalmente se coloca al comienzo del archivo del programa, y ​​esta declaración es global en este momento. Esta declaración es visible en todas partes en el ámbito global, por lo que puede ser utilizada por todas las funciones en el mismo ámbito. Las declaraciones de tipo de estructura también se pueden colocar dentro de las funciones, en cuyo caso la declaración es local.

Explicación:
(1) El tipo de estructura y el tipo de datos comunes (como int, char, double, etc.) son el nombre del tipo, no una entidad del tipo, por lo que no se asignará espacio de almacenamiento para el tipo de estructura.
(2) Cuando se declara el tipo de estructura, el miembro puede volver a ser un tipo de estructura. (Es decir, puede estar anidado)

2. Estructuración de instancias de tipo

La definición de un objeto de estructura se denomina instanciación de tipo de estructura, la cual asigna unidades de memoria al objeto de estructura de acuerdo con el tipo de datos. Hay dos formas de definir objetos de estructura.

1) Declare primero el tipo de estructura y luego defina el objeto

struct atudent;
student a,b;

2) Declare el objeto mientras declara el tipo de estructura

DATE { //日期类型
 int year,month,day; //年，月，日 整型
} d1,d2; //定义结构体对象

3. La forma de memoria del objeto estructura.

Después de crear una instancia del objeto de estructura, el objeto obtendrá espacio de almacenamiento

struct STUDENT { //学生信息类型
	int no; //声明一个整型数据成员表示学号
	char name[21]; //声明一个字符串数据成员表示姓名
	char sex; //声明一个字符数据成员表示性别
	int age; //声明一个整型数据成员年龄
	char qq[11]; //声明一个字符串数据成员表示QQ号
	double score; //声明一个浮点型数据成员表示成绩
};

Se puede inicializar cuando se define el objeto de estructura

struct STAFF { //职员信息类型
 int no; //工号，整型
 char name[21]; //姓名，字符串
 char sex; //性别，字符型
 DATA birthday; //出生日期，结构体类型
 double salary; //薪水，浮点型
};
STAFF s1={1001,"Li Min",'M',{1980,10,6},2700.0};
STAFF s2={1002,"Ma Gang",'M',1978,3,22,3100.0};

4. Estructura de referencia de miembro de objeto

El uso del objeto estructura es principalmente para referirse a sus miembros, la forma general es:
nombre del objeto estructura.

STAFF a,b;
a.no=10002; //将10002赋值给a对象中的no成员
b.salary=a.salary+500.0; //在表达式中可以引用对象成员
a.no++; //按优先级等价于(a.no)++

1. Si el miembro en sí es un objeto de estructura, debemos usar el operador de referencia de miembro, referenciado nivel por nivel.
2. No puede ingresar o generar un objeto de estructura como un todo, solo puede ingresar o generar miembros del objeto de estructura uno por uno. (Pero puede implementarse mediante una función personalizada o un operador sobrecargado)
3. Los objetos de estructura pueden tener operaciones asignadas, pero no pueden usarse para operaciones aritméticas, operaciones relacionales, etc.

5. Estructuras y matrices, punteros, funciones.

Estructuras y matrices. Los elementos de matriz pueden ser tipos de estructura, convirtiéndose en matrices de estructura. Tales como:

struct POINT { //点类型
	int x,y; //平面上点的x、y坐标
};
POINT points[100]; //表示100个点的数据对象

La estructura de matriz unidimensional se inicializa, y la eliminación debe realizarse en forma de memoria, con una correspondencia uno a uno.

struct RECT { //矩形框类型
	int left,top,right,bottom;
};
RECT rects[3]={{1,1,10,10}, {5,5,25,32},{100,100,105,200}};

Para hacer referencia a un miembro de matriz de una estructura, debe combinar la operación de subíndice de matriz y la operación de referencia de miembro de objeto:

rects[0].left=10;

Los tipos de estructura pueden contener miembros de matriz Los tipos de miembros de matriz pueden ser tipos de datos básicos, tipos de puntero o tipos de estructura.

struct TRIANGLE { //三角形类型
	POINT p[3];//由3个平面上的点描述三角形
};
TRIANGLE tri;
tri.p[0].x=10,tri.p[0].y=10;
//结构体对象.数组成员[下标表达式].成员名

Estructura y puntero . La dirección de cada miembro de la estructura objeto: & nombre del objeto. Nombre del miembro.

int *p1; //指向no成员的指针类型是int*
char *s1,*s2; //指向name、sex成员的指针类型是char*
STAFF m; //结构体对象
p1=&m.no; //取no成员的地址

DATE *p2; //指向birthday成员的指针类型是DATE*
s1=m.name; //name成员是数组，数组名即是地址
s2=&m.sex; //取sex成员的地址
p2=&m.birthday; //取birthday成员的地址

Dirección del objeto estructura: y nombre del objeto. Por ejemplo

struct STAFF m, *p; //指向结构体对象的指针
p=&m; //取结构体对象的地址

Suponiendo que p es un puntero a un objeto de estructura, hay dos
formas de referirse a los miembros de objeto de estructura a través de p :
method Método del objeto: (* p). Nombre del miembro;
② Método de puntero: p-> nombre del miembro.
El segundo método se usa más comúnmente, -> operador de referencia para miembros de puntero.

struct STAFF *p;
p->no=10002; //将10002赋值给对象中的no成员，指针成员引用运算结果是左值（即成员本身）
p->salary=p->salary+500.0; //在表达式中引用指针指向的成员
p->no++; //按优先级等价于(p->no)++

Si el miembro mismo es un puntero a un objeto de estructura, el miembro puntero se usa para referirse al miembro de referencia en el primer nivel.

DATE d={1981,1,1};
TEACHER { //教师信息类型
 int no; //工号
 char name[21]; //姓名
 DATE *pbirthday; //出生日期
} a={1001,"Li Min",&d}, *p=&a;
p->no=10001; //通过指针p引用a的no成员
p->pbirthday->year=2008; //通过指针p->pbirthday引用d的year成员

Estructura y función
Los objetos de estructura se utilizan como parámetros de entrada, utilizando la función de transferencia de valor:

struct DATA {
 int data; //整型成员
 char name[10]; //数组成员
};
void fun1(DATA x); //函数原型
void fun2(){
	DATA a={1,"LiMin"};
	fun1(a); //函数调用
}

La matriz del problema de estructura se usa como parámetro de entrada y la dirección se usa para la transmisión. El parámetro real de la llamada a la función es un nombre de matriz, y el parámetro formal debe ser una matriz de estructuras del mismo tipo. Usando el método de transferencia de dirección, la primera dirección del grupo de parámetros formales es exactamente la misma que el grupo de parámetros real.

void fun3(DATA X[]); //函数原型
void fun4(){
	DATA A[3]={1,"LiMin",2,"MaGang",3,"ZhangKun"};
	fun3(A); //函数调用
}

Use el puntero de estructura como parámetro de función y use el método de transferencia de dirección

void fun5(DATA *p); //函数原型
void fun6(){
	DATA a={1,"LiMin"};
	fun5(&a); //函数调用
}

El tipo de retorno de una función puede ser un tipo de estructura.

DATA fun8(){ 
	DATA a={1,"LiMin"};
	return a; //返回结构体对象，复制到临时对象中
}
void fun9(){
	DATA b;
	b=fun8(); //函数返回结构体对象，并且赋值
}

Comunidad

$\ color {# FF3030} {Compartir memoria entre cada miembro y otros miembros de la comunidad. }$

union A {
	int m,n; //整型成员
	char a,b; //字符成员
};

Estructuras y bienes comunes:
$\ color {# FF3030} {La longitud de memoria común es la longitud máxima de la memoria de todos los miembros,}$ estructura de la longitud de memoria es la suma de las longitudes de toda la memoria. Puede usar sizeof para encontrar la longitud de su memoria.

La inicialización se puede realizar al definir un objeto común, pero solo un miembro puede recibir el valor inicial,

union A x={ 5678 }; //正确，只能给出1个初值
union A y={5,6,7,8}; //错误，试图给出4个初值（结构体做法）

Dado que los miembros son espacio de almacenamiento compartido , las siguientes características cuando se usan miembros del objeto común:

1. Modificar un miembro hará que otros miembros cambien, y todos los miembros almacenan el resultado de la última modificación;
2. Los valores de todos los miembros son los mismos, la diferencia es que diferentes tipos determinan el uso de todo o parte de este valor;
3. El valor de la dirección inicial de todos los miembros es el mismo, por lo que generalmente solo se ingresa e inicializa un miembro;

La comunidad se puede usar para probar extremos grandes y pequeños:

void checkCPU()
{
    union MyUnion{
        int a;
        char c;
    }test;
    test.a = 1;
    if (test.c == 1)
        cout << "little endian" <<endl;
    else cout << "big endian" <<endl;
}

Tipo de enumeración

Los tipos enumerados son tipos definidos por el usuario compuestos de múltiples constantes enumeradas con nombre

enum DAYS {MON,TUE,WED,THU,FRI,SAT,SUN};

1. Puede especificar un valor para una constante de enumeración nombrada cuando (solo) declara un tipo de enumeración.

enum COLORS {RED=10,GREEN=8,BLUE,BLACK,WHITE};

Entonces ROJO es 10, VERDE es 8, AZUL es 9, NEGRO es 10 y BLANCO es 11.

2. Una constante de enumeración con nombre es un valor de constante entero, también conocido como enumerador, y
   debe ser único dentro del alcance del tipo de enumeración . Las constantes enum denominadas son valores, no valores.

RED=10; //错误，RED不是左值，不能被赋值
GREEN++; //错误，GREEN不是左值，不能自增自减

typedef

Puede usar typedef para declarar un nuevo nombre de tipo en lugar de un nombre de tipo existente, en la forma:
► donde el nombre de tipo existente debe ser el nombre de un tipo de datos existente, y el nuevo nombre de tipo es un identificador

typedef 已有类型名 新类型名;

Secuencia de caracteres, solía escribirse en mayúscula; si se trata de varios nombres de tipo nuevos, use una coma (,) como intervalo. Finalmente, termine con un punto y coma (;). Por ejemplo:

typedef unsigned char BYTE; //按计算机汇编指令习惯规定的字节型
typedef unsigned short WORD; //按计算机汇编指令习惯规定的字类型
typedef unsigned long DWORD; //按计算机汇编指令习惯规定的双字类型