Saltar al contenido principal
LibreTexts Español

10.1: Introducción

  • Page ID
    82372
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    \( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

    ( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\id}{\mathrm{id}}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\kernel}{\mathrm{null}\,}\)

    \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\)

    \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\)

    \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    \( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

    \( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

    \( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vectorC}[1]{\textbf{#1}} \)

    \( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

    \( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

    \( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

    \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    C permite datos compuestos llamados estructuras, o struct para abreviar. La idea es usar una variedad de los tipos de datos básicos como float o int para describir algún tipo de objeto. Las estructuras pueden contener varios de cada tipo junto con punteros, matrices e incluso otras estructuras. Hay muchos usos para tal constructo y las estructuras son muy comunes en el código C de producción.

    Como ejemplo, es posible que deseemos describir un componente electrónico tal como un transistor. ¿Qué tipo de cosas necesitamos? Hay varios parámetros de rendimiento que se pueden usar como ganancia de corriente, voltaje de ruptura y disipación de potencia máxima. Todos estos ítems pueden ser representados como variables dobles. Habrá un número de modelo. Esto probablemente será una cadena ya que puede contener letras (como “2N3904”). Será necesario que haya un código del fabricante. Esto podría ser un int. Un dispositivo del mundo real tendrá muchos más parámetros que estos cinco, pero estos serán suficientes para nuestros propósitos. Si solo tienes un transistor con el que lidiar, cinco variables separadas no es un gran problema para hacer un seguimiento. Por otro lado, ¿y si tienes un gran número de partes como en una base de datos? Quizás hay 1000 dispositivos. Crear 5000 variables separadas y mantenerlas rectas presenta un pequeño desafío. Sería bueno si pudiéramos combinar los cinco elementos juntos en una “súper variable”. Entonces, todo lo que tenemos que preocuparnos es crear 1000 de ellos para la base de datos (quizás con una matriz, aunque hay otras técnicas). No debería haber problema de confundir la ganancia actual de un dispositivo con la de otro. Aquí es donde entran las estructuras. A continuación se muestra un ejemplo de cómo definiríamos esta estructura de transistores y las instancias asociadas.

    struct transistor {
        double        currentgain;
        double        breakdown;
        double        maxpower;
        short int     manufacturer;
        char          model[20];
    };
    
    struct transistor my_transistor;
    struct transistor *ptransistor;
    

    Hemos definido una estructura de tipo transistor. También hemos declarado una instancia de un transistor struct llamado my_transistor, junto con un puntero a un transistor struct llamado ptransistor. Los cinco elementos son referidos como los campos de la estructura (por ejemplo, el campo currentgain). Tenga en cuenta que esta estructura contiene una matriz de caracteres para el nombre/número del modelo. El modelo no puede superar los 19 caracteres (19 más los rendimientos nulos de terminación 20 declarados). Es poco probable que alguna vez tengamos el nombre/número del modelo tan largo, pero si por casualidad lo hacemos, tendremos que truncarlo.

    Para establecer o recuperar valores de una instancia, utilizamos un punto para separar el nombre de la estructura del campo de interés. Aquí hay algunos ejemplos:

    my_transistor.currentgain = 200.0;
    my_transistor.maxpower = 50.0;
    my_transistor.manufacturer = 23;
    

    En la última asignación, puede ser mejor usar un #define en lugar de un número duro. Por ejemplo, coloque la siguiente definición en un archivo de encabezado y luego use la siguiente asignación:

    #define MOTOROLA 23
    
    my_transistor.manufacturer = MOTOROLA;
    

    Para establecer el campo del modelo, podrías hacer algo como esto:

    strcpy( my_transistor.model, “2N3904” );
    

    Recuerda, strcpy () necesita direcciones. El literal de cadena de comillas dobles produce esto automáticamente. Para el campo modelo, estamos usando el atajo descrito en trabajos anteriores. La línea anterior es equivalente a:

    strcpy( &(my_transistor.model[0]), “2N3904” );
    

    Si necesitas usar un campo en un cálculo o comparación, el acceso no cambia:

    if( my_transistor.breakdown > 75.0 )
        printf(“Breakdown voltage is at least 75 volts!\n”);
    

    Una buena pregunta en este punto es si o no el orden declarado de los campos hace alguna diferencia. Esto depende del compilador y del hardware de destino. En algunos procesadores, las variables de múltiples bytes como enteros largos y cortos, flotantes y punteros deben estar alineadas con palabras. Por ejemplo, se puede requerir un int corto para comenzar en una dirección par o podría requerirse un float para comenzar en una dirección divisible por cuatro. En tal sistema, una estructura declarada con el orden de char, float, char, int necesitará bytes pad entre algunos campos para asegurar la alineación y ocupará más espacio de memoria que si la estructura estuviera organizada como float, int, char, char. Esto es de particular importancia si se van a utilizar grandes matrices de estructuras.


    This page titled 10.1: Introducción is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by James M. Fiore via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.