Definición de variables de estructura y tipos de estructura

1. Definición del tipo de estructura

Método de definición 1:

Typedef struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域
} *LinkList;

Método de definición 2:

struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域

};
Typedef struct  LNode  *LinkList;

Los dos métodos de definición anteriores son equivalentes; lo que se hace es definir*LinkListdefinir comostruct LNodetipo, es decirLinkListse define como un nombre de tipo. De esta manera se puede usarLinkListpara definir y declarar nuevas variables, por ejemplo:

LinkList  L;

es decir, seLdefine comostruct LNodevariable puntero de tipo.

2. Definición de variables de tipo de estructura

Método de definición 1:

struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域

}LnodeA;

Método de definición 2:

struct  LNode {
   int  data;  // 数据域
   struct LNode   *next;  // 指针域

};
struct  LNode LnodeA;

Los dos métodos de definición anteriores también son equivalentes; así seLnodeAdefine como unastruct LNodevariable de tipo, es decirLnodeAcomo unstruct LNodenombre de variable de tipo.

Formas de definición de estructuras y tablas internas

1. Estructura, área de tabla transparente, DATA ELEMENT, DOMAIN

Una tabla transparente es una descripción lógica de una tabla física; contiene muchos campos, y algunos campos se definen como PRIMARY KEY. Los campos a su vez contienen DATA ELEMENT, que se utiliza para describir propiedades lingüísticas y técnicas. DATA ELEMENT a su vez contiene DOMAIN, que define el tipo de datos y la longitud del campo.

Una estructura se utiliza generalmente para definir una variable de estructura, con almacenamiento de datos temporales, sin PRIMARY KEY. La estructura contiene COMPONENT, no FIELD.

2. Los atributos de la tabla interna se dividen en tres tipos: LINE TYPE, KEY, TABLE KIND.

LINE TYPE: en una INTERNAL TABLE, una fila individual se llama LINE TYPE; la estructura de cada fila es la misma.

KEY: equivalente a la clave primaria en una base de datos. Es útil al ordenar; puede ser UNIQUE o NON-UNIQUE.

TABLE KIND: se divide en STANDARD, SORTED y HASHED.

Definición de los tres tipos de tablas internas

Tabla estándar:

DATA itab1 TYPE STANDARD TABLE OF scarr WITH NON-UNIQUE KEY carrid.

Tabla ordenada:

DATA itab2 TYPE SORTED TABLE OF scarr WITH NON-UNIQUE KEY carrid.

Tabla hash:

DATA itab3 TYPE HASHED TABLE OF scarr WITH UNIQUE KEY carrid.

Método de definición general (tabla estándar)

Definir una tabla estándar a partir de una tabla de base de datos

DATA itab4 TYPE TABLE OF scarr.

Definir una tabla estándar a partir de una variable de estructura creada por el usuario (la más común)

DATA: BEGIN OF wa,
    carrid TYPE scarr-carrid,
    carrnamen TYPE scarr-carrname,
    END OF wa.
DATA itab5 LIKE TABLE OF wa.

Definir una tabla estándar a partir de un tipo de tabla en el diccionario de datos

DATA itab6 TYPE ztabtype00_1.

Definir una tabla interna a partir de otra tabla interna

DATA itab7 LIKE itab6.

Definir una estructura a partir de una tabla interna

DATA wa1 LIKE LINE OF itab7.

3. Formas de definir estructuras

Definir variables de estructura (o tipos) del programa a partir de tablas o estructuras en el diccionario de datos

types str1 type spfli.
data str2 type  sflight.

Definir variables de estructura (o tipos) personalizadas en el programa: la más común

data: begin of wa,
carrid type spfli-carrid,
com(10) type c,
end of wa.

Definir una estructura a partir de una tabla interna

data wa like line of itab.

Nota:Lo que se define a partir de una tabla de base de datos siempre es una estructura

Asignación de campos con el mismo nombre (importante)

Move-corresponding A  to  B.

READ se utiliza para leer un solo registro de una tabla interna

read table itab like table of wa.

Para leer múltiples registros de una tabla interna se debe usar LOOP

loop at itab into wa.

Explicación en el lenguaje C/C++

Definición de estructura

Una estructura (struct) es una colección de datos compuesta por una serie de datos del mismo tipo o de tipos diferentes; también se llama estructura.

Función de la estructura

La estructura es igual que otros tipos de datos básicos, como int o char; solo que la estructura puede convertirse en el tipo de datos que desees, para facilitar su uso posterior.

En proyectos reales, las estructuras existen en gran cantidad. Los desarrolladores suelen usar estructuras para encapsular ciertos atributos y formar nuevos tipos.

La función de la estructura en las funciones no es simplificar; su función principal es el encapsulamiento. La ventaja del encapsulamiento es que puede reutilizarse. Permite que el usuario no tenga que preocuparse por qué es, solo debe usarla según la definición.

Tamaño de la estructura y alineación de memoria

El tamaño de una estructura no es simplemente la suma de sus elementos, porque las computadoras convencionales actuales usan CPU de 32 bits de longitud de palabra. Para este tipo de CPU, obtener un número de 4 bytes es más eficiente y conveniente que obtener uno de 1 byte. Por lo tanto, si la dirección inicial de cada miembro en la estructura es múltiplo de 4, la extracción de elementos de datos será relativamente más eficiente. Este es el origen de la alineación de memoria.

El compilador de cada plataforma específica tiene su propio "factor de alineación" predeterminado (también llamado módulo de alineación). El programador puede usar el comando de precompilación#pragma pack(n)，n=1,2,4,8,16 para cambiar este coeficiente, donde n es el "factor de alineación" que desees especificar.

Reglas:

1. Regla de alineación de miembros de datos: el primer miembro de datos de una estructura (struct) (o unión (union)) se coloca en el offset 0; a partir de ahí, la alineación de cada miembro de datos se realiza según#pragma packel valor especificado y la longitud del propio miembro de datos, el menor de los dos.
2. Regla de alineación general de la estructura (o unión): después de que los miembros de datos completen su respectiva alineación, la estructura (o unión) en sí también debe alinearse. La alineación se realizará según < span class="marked">#pragma packel valor especificado y la longitud máxima de los miembros de datos de la estructura (o unión), el menor de los dos.
3. Combinando las inferencias de 1 y 2: cuando el valor n de #pragma pack es igual o supera la longitud de todos los miembros de datos, el tamaño de este valor n no tendrá ningún efecto.

Estructuras en C++

En el lenguaje C, se puede definir un tipo de estructura para agrupar múltiples variables relacionadas como un todo. Las variables dentro de una estructura pueden ser del mismo tipo, parcialmente iguales o completamente diferentes. En C, una estructura no puede contener funciones. En la programación orientada a objetos, los objetos tienen estado (atributos) y comportamiento; el estado se almacena en variables miembro y el comportamiento se implementa mediante métodos miembro (funciones). Una estructura en C solo puede describir el estado de un objeto, no su comportamiento. En C++, considerando la continuidad de la transición de C a C++, las estructuras se han extendido; las estructuras de C++ pueden contener funciones, de modo que también tienen la funcionalidad de una clase. A diferencia de class, las funciones contenidas en una estructura son públicas por defecto, no privadas.

Ejemplo de salida por consola en C++:

Ejemplo

#include <cstdlib>　 #include <iostream>//Definir estructura using namespace std;　 struct point　 {　　 //Contiene dos variables miembro int x;　　 int y;　 };　　 int main(int argc, char *argv[])　 {　　 struct point pt;　 pt.x=1;　 pt.y=2;　 cout<<pt.x<<endl<<pt.y<<endl; return EXIT_SUCCESS; }

Diferencias entre estructuras y clases en C++

Las clases y las estructuras en C++ solo tienen dos diferencias; aparte de estas, no hay ninguna otra diferencia.

(1) En class, los permisos de acceso de los miembros por defecto son private, mientras que en struct son public.
(2) La herencia de class es privada por defecto, mientras que la herencia de struct es pública por defecto.

¿Cuál es la diferencia entre estas dos definiciones?

typedef struct student
{
    int num;
    struct student *next;
}student;

struct student
{
    int num;
    struct student *next;
};

La segunda, struct student, define una estructura student, ¿entiendes eso?

La primera usa typedef para redefinir el nombre del tipo de estructura struct student como student, es decir, struct student y student representan la misma cosa, ambos son identificadores de un tipo. Por ejemplo, typedef int zhengshu; significa que renombras el tipo entero int como zhengshu; en la definición siguiente, int i; y zhengshu i; son equivalentes.

Una estructura es una combinación de varias variables compuestas por tipos de datos básicos y nombradas con un identificador. En una estructura se pueden usar diferentes tipos de datos.

Declaración de estructura y definición de variables de estructura

En Turbo C, una estructura también es un tipo de datos y se pueden usar variables de estructura. Por lo tanto, al igual que otros tipos de variables, se debe definir la variable de estructura antes de usarla.

El formato general para definir una variable de estructura es:

struct 结构名
{ 
    类型 变量名;
    类型 变量名;
...
} 结构变量;

El nombre de estructura es el identificador de la estructura, no el nombre de la variable.

Los tipos son los cinco tipos de datos descritos en la sección 2 (entero, punto flotante, carácter, puntero y vacío).

Cada variable de tipo que compone una estructura se llama miembro de estructura; es como un elemento de un arreglo, pero los elementos de un arreglo se acceden por índice, mientras que en una estructura los miembros se acceden por nombre de variable.

A continuación se muestra un ejemplo para explicar cómo definir una variable de estructura.

struct string 
{ 
    char name[8]; 
    int age; 
    char sex[4]; 
    char depart[20]; 
    float wage1,wage2,wage3; 
}person;

Este ejemplo define una variable de estructura person con nombre de estructura string. Si se omite el nombre de variable person, se convierte en una declaración de estructura. También se pueden definir variables de estructura usando el nombre de estructura ya declarado. Al definir de esta manera, el ejemplo anterior se convierte en:

struct string 
{ 
    char name[8]; 
    int age; 
    char sex[4]; 
    char depart[20]; 
    float wage1,wage2,wage3; 
}; 
struct string person;

Si es necesario definir varias variables de estructura con la misma forma, este método es más conveniente; primero se declara la estructura y luego se usa el nombre de la estructura para definir las variables.

Por ejemplo:

struct string Tianyr, Liuqi, ...;

Si se omite el nombre de la estructura, se denomina estructura anónima; esta situación suele aparecer dentro de una función. Con esta estructura, el ejemplo anterior se convierte en:

struct 
{ 
    char name[8]; 
    int age; 
    char sex[4]; 
    char depart[20]; 
    float wage1,wage2,wage3; 
} Tianyr, Liuqi;

Uso de variables de estructura

Una estructura es un nuevo tipo de datos, por lo que las variables de estructura también pueden asignarse y operarse como variables de otros tipos; la diferencia es que la variable de estructura toma a los miembros como variables básicas.

La forma de representar un miembro de estructura es:

variable de estructura.nombre de miembro

Si se considera "variable de estructura.nombre del miembro" como un todo, el tipo de datos de ese todo es el mismo que el del miembro en la estructura, por lo que se puede usar como las variables explicadas anteriormente.

El siguiente ejemplo define una variable de estructura, donde cada miembro recibe datos desde el teclado, luego suma los números de punto flotante de la estructura y muestra el resultado de la operación. Observe cómo se accede a los diferentes miembros de la estructura en este ejemplo.

Ejemplo

#include <stdio.h> #include <conio.h> int main() { struct { char name[8]; int age; char sex[4]; char depart[20]; float wage1,wage2,wage3; }a; float wage; char c='Y'; while(c=='Y'||c=='y') { printf(\nName:); scanf(%s, a.name); printf(Age:); scanf(%d, &a.wage); printf(Sex:); scanf(%s, a.sex); printf(Dept:); scanf(%s, a.depart); printf(Wage1:); scanf(%f, &a.wage1); printf(Wage2:); scanf(%f, &a.wage2); printf(Wage3:); scanf(%f, &a.wage3); wage=a.wage1+a.wage2+a.wage3; printf(The sum of wage is %6.2f\n, wage); printf(Continue?); c=getche(); } }

Arreglos de estructuras y punteros a estructuras

La estructura es un nuevo tipo de datos; igualmente puede haber arrays de estructuras y punteros a estructuras.

1. Arrays de estructuras

Un array de estructuras es un conjunto de variables del mismo tipo de estructura. Por ejemplo, si se desea definir el nombre, sexo, edad y dirección de 40 estudiantes de una clase, se puede definir como un array de estructuras. Como se muestra a continuación:

struct
{ 
    char name[8]; 
    char sex[4]; 
    int age; 
    char addr[40]; 
}student[40];

También se puede definir como:

struct string
{ 
    char name[8]; 
    char sex[4]; 
    int age; 
    char addr[40]; 
}; 
struct string student[40];

Cabe señalar que el acceso a los miembros de un array de estructuras toma el elemento del array como variable de estructura; su forma es:

elemento de matriz de estructura.nombre de miembro

Por ejemplo:

student[0].name 
student[30].age

En realidad, un array de estructuras equivale a una construcción bidimensional: la primera dimensión son los elementos del array de estructuras, cada elemento es una variable de estructura; la segunda dimensión son los miembros de la estructura.

Nota: Los miembros de un array de estructuras también pueden ser variables de tipo array.

Por ejemplo:

struct a 
{ 
    int m[3][5]; 
    float f; 
    char s[20]; 
}y[4];

Para acceder a la variable de estructura en la estructura a,y[2]esta variable se puede escribir comoy[2].m[1][4]

2. Punteros a estructuras

Un puntero a estructura es un puntero que apunta a una estructura. Se define mediante un operador * colocado antes del nombre de la variable de estructura. Por ejemplo, usando la estructura explicada anteriormente para definir un puntero a estructura:

struct string
{ 
    char name[8]; 
    char sex[4]; 
    int age; 
    char addr[40]; 
}*student;

También se puede omitir el nombre del puntero a estructura y solo hacer la declaración de la estructura, luego usar la siguiente sentencia para definir el puntero a estructura.

struct string *student;

El acceso a los miembros de una estructura mediante un puntero a estructura difiere en la forma de expresión del acceso a los miembros mediante una variable de estructura. El acceso mediante puntero a estructura se representa como:

puntero de estructura->miembro de estructura

donde->son dos símbolos-y>que combinados parecen una flecha que apunta al miembro de la estructura. Por ejemplo, para asignar valores a name y age en la estructura definida anteriormente, se pueden usar las siguientes sentencias:

strcpy(student->name, Lu G.C); 
student->age=18;

En realidad,student->namees(*student).namela forma abreviada de.

Cabe señalar que un puntero a estructura es un puntero que apunta a una estructura, es decir, a la dirección del primer miembro de la estructura. Por lo tanto, antes de usarlo se debe inicializar el puntero a estructura, es decir, asignar un espacio de bytes de la longitud total de la estructura. Esto se puede hacer con la siguiente función; tomando el ejemplo anterior:

student=(struct string*)malloc(size of (struct string));

size of (struct string)Calcula automáticamente la longitud en bytes de la estructura string; la función malloc() define un área de memoria del tamaño de la longitud de la estructura y luego devuelve su dirección inicial como puntero a la estructura.

Nota:

1. La estructura es un tipo de datos, por lo que las variables de estructura o variables puntero a estructura definidas también pueden ser variables locales o globales, según la posición donde se definan.
2. El nombre de una variable de estructura no es la dirección que apunta a la estructura; esto difiere del significado del nombre de un array. Por lo tanto, si se necesita obtener la dirección del primer miembro de la estructura, debe ser:&[nombre de la variable de estructura]。
3. Forma compleja de estructuras: estructuras anidadas

Una estructura anidada significa que un miembro de la estructura puede incluir otra estructura; Turbo C permite este tipo de anidamiento.

Por ejemplo: a continuación se muestra una estructura con anidamiento

struct string
{ 
    char name[8]; 
    int age; 
    struct addr address; 
} student;

Donde: addr es el nombre de estructura de otra estructura; primero se debe realizar la declaración, es decir:

struct addr
{ 
    char city[20]; 
    unsigned lon zipcode; 
    char tel[14]; 
}

Si se desea asignar un valor a zipcode en la estructura address, que es miembro de la estructura student, se puede escribir:

student.address.zipcode=200001;

Los nombres de los miembros de la estructura se listan uno a uno desde la capa más externa hasta la más interna; es decir, la forma de expresar un miembro de estructura anidada es:

nombre de variable de estructura.nombre de variable de estructura anidada.nombre de miembro de estructura

Puede haber muchas estructuras anidadas; el nombre del miembro de estructura es el nombre del miembro en la estructura más interna que no es una estructura.

Enlace original: https://www.cnblogs.com/yuxinJ/p/4688496.html