Introducción al Lenguaje de Programación C99: Parte II

En este artículo, vamos a descubrir algunas adiciones más interesantes a C89 que nos dieron el estándar C99:
 

1. Listas de argumentos variables : C99 presenta pequeños cambios en el preprocesador . Las macros pueden aceptar un número variable de argumentos. Estas Macros se indican con puntos suspensivos (…) en su declaración. Estos argumentos variables están representados por el identificador de preprocesador integrado __VA_RAGS .
    

#include <stdio.h>
#include <string.h>
 
#define compare(compfunc, ...) compfunc(__VA_ARGS__)
 
int main()
{
    // Here compare(strlen, "one")
    // transforms to strlen("one")
    printf("Length is %lu\n",
           compare(strlen, "one"));
 
    // compares variable arguments
    printf("String Comparison Result: %d\n",
           compare(strcmp, "one", "one"));
 
    return 0;
}

Length is 3
String Comparison Result: 0

1.  
2. Operador _Pragma : C99 especifica la implementación de pragma mediante el uso del operador _Pragma. 
   Sintaxis: 
    

_Pragma("directive")

directive is the pragma being called.

1. Este operador _Pragma ayuda a los pragmas a participar en el reemplazo de macros.
   Algunos pragmas integrados son: 

    

1. Estas tres macros se usan raramente. Esta función soluciona un problema importante con ‘#pragma’: al ser una directiva, no se puede producir como resultado de una macro expansión.
   Se revisan algunas macros C89 incorporadas y se agregan nuevas macros como __STDC_HOSTED__, __STDC__VERSION, __STDC_IEC_559__(admite aritmética de punto flotante), __STDC_IEC_599_COMPLEX__(admite aritmética compleja), STDC_ISO_10646__(da la fecha de especificación).
    
2. Declaración de variables dentro del bucle: en el estándar C89, las variables de bucle deben declararse antes de la inicialización del código. Pero en C99 podemos declarar la variable de bucle en la parte de inicialización del bucle. La variable declarada dentro de un ciclo for será local para el ciclo. 
    

#include <stdio.h>
 
int main(void)
{
    // declare variable i at initialization
    int n = 5;
    for (int i = 0; i < n; i++)
        printf("%d ", i);
}

0 1 2 3 4

1. Aquí el alcance de i está solo dentro del bucle.
    
2. Literales compuestos : los literales compuestos son expresiones de array , estructura o unión que representan objetos del tipo dado.
   Ejemplo: 
    

int *a = (int[]){11, 12, 13}

1. La expresión anterior crea un puntero a un entero llamado a que apunta al primero de una array de tres elementos de valores enteros.
   Un literal compuesto generalmente se crea especificando un nombre de tipo entre paréntesis seguido de una lista de inicialización encerrada entre llaves como se muestra arriba.
   Un literal compuesto creado en el ámbito del archivo existe en todo el programa. Si se crea un literal compuesto dentro de un bloque, se destruirá cuando se deje el bloque, es decir, el literal compuesto es local dentro del bloque pero se desconoce fuera del bloque. 
    

#include <stdio.h>
 
int main()
{
    int* a = (int[]){ 11, 12, 13 };
    for (int i = 0; i < 3; i++)
        printf("%d ", a[i]);
}

11 12 13

1.  
2. Miembros de estructura de array flexible : C99 permite especificar una array sin tamaño como último miembro de la estructura. Estos otros elementos deben declararse antes que los elementos de array sin tamaño. Estos tamaños se asignan dinámicamente más tarde mediante malloc() . 
   El siguiente programa de ejemplo demuestra el uso de estructuras de array flexibles.
    

#include <stdio.h>
#include <stdlib.h>
 
struct GFG {
    int a;
    int arr[];
};
 
struct GFG* p;
 
int main()
{
    // Here arr will be instantiated
    // as a[10] as we use
    // sizeof(GFG)+10*sizeof(int)
    p = (struct GFG*)malloc(
        sizeof(struct GFG)
        + 10 * sizeof(int));
 
    // Results 0 as every element
    // will be set to zero
    printf("%d\n", p->arr[0]);
}

0

1.  
2. Inicialización designada en arrays: el estándar C99 ayuda a inicializar algunos elementos de la array durante la declaración. Esta característica es principalmente útil para los programadores que trabajan en arreglos dispersos.
   El siguiente programa muestra la inicialización designada en arrays. 
    

#include <stdio.h>
 
int main()
{
    // initializes index 0 and 1 in a[5]
    int a[5] = {[0] = 100, [1] = 200 };
 
    for (int i = 0; i < 5; i++)
        printf("%d ", a[i]);
}

100 200 0 0 0

1. También podemos usar esta inicialización designada en estructuras de la siguiente manera: 
    

#include <stdio.h>
 
struct GFG {
    int a;
    int b;
    int c;
 
    // initializes a and c
    // of structure object ob
} ob = {.a = 1, .c = 20 };
 
int main()
{
    printf("The values of a and c"
           " in struct GFG are %d %d",
           ob.a, ob.c);
}

The values of a and c in struct GFG are 1 20