Características ocultas de C

Sé que hay un estándar detrás de todas las implementaciones del compilador de C, por lo que no debería haber características ocultas. A pesar de eso, estoy seguro de que todos los desarrolladores de C tienen trucos ocultos / secretos que usan todo el tiempo.

Punteros de función. Puede usar una tabla de punteros de función para implementar, por ejemplo, intérpretes rápidos de código de hilos indirectos (FORTH) o despachadores de código de bytes, o para simular métodos virtuales similares a OO.

Luego hay gemas ocultas en la biblioteca estándar, como qsort (), bsearch (), strpbrk (), strcspn () [estas dos últimas son útiles para implementar un reemplazo strtok ()].

Una característica errónea de C es que el desbordamiento aritmético con signo es un comportamiento indefinido (UB). Por lo tanto, cada vez que vea una expresión como x + y, ambas son entradas firmadas, podría desbordarse y causar UB.

Es más un truco del compilador GCC, pero puede dar indicaciones de ramificación al compilador (común en el kernel de Linux)

#define likely(x)       __builtin_expect((x),1)
#define unlikely(x)     __builtin_expect((x),0)

ver: http://kerneltrap.org/node/4705

Lo que me gusta de esto es que también agrega algo de expresividad a algunas funciones.

void foo(int arg)
{
     if (unlikely(arg == 0)) {
           do_this();
           return;
     }
     do_that();
     ...
}

int8_t
int16_t
int32_t
uint8_t
uint16_t
uint32_t

Se trata de un elemento opcional en el estándar, pero debe ser una característica oculta, ya que las personas los redefinen constantemente. Una base de código en la que he trabajado (y todavía lo hago, por ahora) tiene múltiples redefiniciones, todas con diferentes identificadores. La mayoría de las veces es con macros de preprocesador:

#define INT16 short
#define INT32  long

Y así. Me dan ganas de arrancarme el pelo. ¡Solo use los malditos tipos de letra enteros estándar!

El operador de coma no se usa ampliamente. Ciertamente se puede abusar de él, pero también puede ser muy útil. Este uso es el más común:

for (int i=0; i<10; i++, doSomethingElse())
{
  /* whatever */
}

Pero puede usar este operador en cualquier lugar. Observar:

int j = (printf("Assigning variable j\n"), getValueFromSomewhere());

Cada declaración se evalúa, pero el valor de la expresión será el de la última declaración evaluada.

inicializando la estructura a cero

struct mystruct a = {0};

esto pondrá a cero todos los elementos de estructura.

Constantes de varios caracteres:

int x = 'ABCD';

Esto se establece xen 0x41424344(o 0x44434241, dependiendo de la arquitectura).

EDITAR: Esta técnica no es portátil, especialmente si serializa el int. Sin embargo, puede ser extremadamente útil crear enumeraciones autodocumentadas. p.ej

enum state {
    stopped = 'STOP',
    running = 'RUN!',
    waiting = 'WAIT',
};

Esto lo hace mucho más simple si está viendo un volcado de memoria sin procesar y necesita determinar el valor de una enumeración sin tener que buscarlo.

Nunca usé campos de bits, pero suenan bien para cosas de nivel ultra bajo.

struct cat {
    unsigned int legs:3;  // 3 bits for legs (0-4 fit in 3 bits)
    unsigned int lives:4; // 4 bits for lives (0-9 fit in 4 bits)
    // ...
};

cat make_cat()
{
    cat kitty;
    kitty.legs = 4;
    kitty.lives = 9;
    return kitty;
}

Esto significa que sizeof(cat)puede ser tan pequeño como sizeof(char).

Comentarios incorporados de Aaron y Leppie , gracias chicos.

C tiene un estándar, pero no todos los compiladores C son totalmente compatibles (¡todavía no he visto ningún compilador C99 totalmente compatible!).

Dicho esto, los trucos que prefiero son aquellos que no son obvios y portátiles en todas las plataformas, ya que dependen de la semántica en C. Por lo general, se trata de macros o aritmética de bits.

Por ejemplo: intercambiar dos enteros sin signo sin usar una variable temporal:

...
a ^= b ; b ^= a; a ^=b;
...

o "extender C" para representar máquinas de estados finitos como:

FSM {
  STATE(x) {
    ...
    NEXTSTATE(y);
  }

  STATE(y) {
    ...
    if (x == 0) 
      NEXTSTATE(y);
    else 
      NEXTSTATE(x);
  }
}

eso se puede lograr con las siguientes macros:

#define FSM
#define STATE(x)      s_##x :
#define NEXTSTATE(x)  goto s_##x

Sin embargo, en general, no me gustan los trucos que son inteligentes, pero hacen que el código sea innecesariamente complicado de leer (como el ejemplo de intercambio) y me encantan los que aclaran el código y transmiten directamente la intención (como el ejemplo de FSM) .

Estructuras entrelazadas como el dispositivo de Duff :

strncpy(to, from, count)
char *to, *from;
int count;
{
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
               } while (--n > 0);
    }
}

Soy muy aficionado a los inicializadores designados, agregados en C99 (y soportados en gcc durante mucho tiempo):

#define FOO 16
#define BAR 3

myStructType_t myStuff[] = {
    [FOO] = { foo1, foo2, foo3 },
    [BAR] = { bar1, bar2, bar3 },
    ...

La inicialización de la matriz ya no depende de la posición. Si cambia los valores de FOO o BAR, la inicialización de la matriz corresponderá automáticamente a su nuevo valor.

C99 tiene una increíble inicialización de estructura de cualquier orden.

struct foo{
  int x;
  int y;
  char* name;
};

void main(){
  struct foo f = { .y = 23, .name = "awesome", .x = -38 };
}

Las estructuras y matrices anónimas son mis favoritas. (cf. http://www.run.montefiore.ulg.ac.be/~martin/resources/kung-f00.html )

setsockopt(yourSocket, SOL_SOCKET, SO_REUSEADDR, (int[]){1}, sizeof(int));

o

void myFunction(type* values) {
    while(*values) x=*values++;
}
myFunction((type[]){val1,val2,val3,val4,0});

incluso se puede usar para instanciar listas vinculadas ...

gcc tiene varias extensiones del lenguaje C que disfruto, que se pueden encontrar aquí . Algunos de mis favoritos son atributos de función . Un ejemplo extremadamente útil es el atributo de formato. Esto se puede usar si define una función personalizada que toma una cadena de formato printf. Si habilita este atributo de función, gcc verificará sus argumentos para asegurarse de que su cadena de formato y argumentos coincidan y generará advertencias o errores según corresponda.

int my_printf (void *my_object, const char *my_format, ...)
            __attribute__ ((format (printf, 2, 3)));

La característica (oculta) que me "sorprendió" cuando vi por primera vez es sobre printf. Esta característica le permite utilizar variables para formatear los especificadores de formato. busque el código, verá mejor:

#include <stdio.h>

int main() {
    int a = 3;
    float b = 6.412355;
    printf("%.*f\n",a,b);
    return 0;
}

el * personaje logra este efecto.

Bueno ... creo que uno de los puntos fuertes del lenguaje C es su portabilidad y estandarización, así que cada vez que encuentro algún "truco oculto" en la implementación que estoy usando actualmente, trato de no usarlo porque trato de mantener mi Código C lo más estándar y portátil posible.

Aserciones en tiempo de compilación, como ya se discutió aquí .

//--- size of static_assertion array is negative if condition is not met
#define STATIC_ASSERT(condition) \
    typedef struct { \
        char static_assertion[condition ? 1 : -1]; \
    } static_assertion_t

//--- ensure structure fits in 
STATIC_ASSERT(sizeof(mystruct_t) <= 4096);

Concatenación constante de cuerdas

Me sorprendió bastante no verlo ya en las respuestas, ya que todos los compiladores que conozco lo respaldan, pero muchos programadores parecen ignorarlo. A veces es realmente útil y no solo al escribir macros.

Caso de uso que tengo en mi código actual: tengo un #define PATH "/some/path/"archivo de configuración (realmente está configurado por el archivo MAKE). Ahora quiero construir la ruta completa, incluidos los nombres de archivo para abrir recursos. Solo va a:

fd = open(PATH "/file", flags);

En lugar de lo horrible, pero muy común:

char buffer[256];
snprintf(buffer, 256, "%s/file", PATH);
fd = open(buffer, flags);

Tenga en cuenta que la solución horrible común es:

• tres veces más largo
• mucho menos fácil de leer
• mucho más lento
• menos potente puesto en un límite de tamaño de búfer arbitrario (pero tendrías que usar un código aún más largo para evitarlo sin una constante constancia de cadenas).
• usar más espacio de pila

Bueno, nunca lo he usado, y no estoy seguro de si alguna vez se lo recomendaría a alguien, pero creo que esta pregunta estaría incompleta sin mencionar el truco de rutina de Simon Tatham .

Al inicializar matrices o enumeraciones, puede poner una coma después del último elemento en la lista de inicializadores. p.ej:

int x[] = { 1, 2, 3, };

enum foo { bar, baz, boom, };

Esto se hizo para que si está generando código automáticamente no tenga que preocuparse por eliminar la última coma.

La asignación de estructura es genial. Muchas personas no parecen darse cuenta de que las estructuras también son valores, y pueden asignarse alrededor, no hay necesidad de usarlas memcpy(), cuando una tarea simple hace el truco.

Por ejemplo, considere una biblioteca imaginaria de gráficos 2D, podría definir un tipo para representar una coordenada de pantalla (entera):

typedef struct {
   int x;
   int y;
} Point;

Ahora, hace cosas que pueden parecer "incorrectas", como escribir una función que crea un punto inicializado a partir de argumentos de función, y lo devuelve, así:

Point point_new(int x, int y)
{
  Point p;
  p.x = x;
  p.y = y;
  return p;
}

Esto es seguro, siempre y cuando (por supuesto) el valor de retorno se copie por valor utilizando la asignación de estructura:

Point origin;
origin = point_new(0, 0);

De esta manera, puede escribir código bastante limpio y orientado a objetos, todo en un estándar simple C.

Extraña indexación vectorial:

int v[100]; int index = 10; 
/* v[index] it's the same thing as index[v] */

Los compiladores de C implementan uno de varios estándares. Sin embargo, tener un estándar no significa que todos los aspectos del lenguaje estén definidos. El dispositivo de Duff , por ejemplo, es una característica 'oculta' favorita que se ha vuelto tan popular que los compiladores modernos tienen un código de reconocimiento de propósito especial para garantizar que las técnicas de optimización no afecten el efecto deseado de este patrón de uso frecuente.

En general, se desaconsejan las funciones ocultas o los trucos de lenguaje, ya que se está ejecutando en el filo de cualquier estándar C que utilice su compilador. Muchos de estos trucos no funcionan de un compilador a otro, y a menudo este tipo de características fallarán de una versión de un conjunto de compiladores de un fabricante determinado a otra versión.

Varios trucos que han roto el código C incluyen:

1. Confiando en cómo el compilador presenta estructuras en la memoria.
2. Suposiciones sobre la endianidad de los enteros / flotantes.
3. Suposiciones sobre la función ABIs.
4. Suposiciones sobre la dirección en que crecen los cuadros de la pila.
5. Suposiciones sobre el orden de ejecución dentro de las declaraciones.
6. Suposiciones sobre el orden de ejecución de las declaraciones en argumentos de función.
7. Suposiciones sobre el tamaño de bits o la precisión de los tipos short, int, long, float y double.

Otros problemas y cuestiones que surgen cada vez que los programadores hacen suposiciones sobre los modelos de ejecución que se especifican en la mayoría de los estándares de C como comportamiento "dependiente del compilador".

Cuando use sscanf, puede usar% n para averiguar dónde debe continuar leyendo:

sscanf ( string, "%d%n", &number, &length );
string += length;

Aparentemente, no puede agregar otra respuesta, así que incluiré una segunda aquí, puede usar "&&" y "||" como condicionales:

#include <stdio.h>
#include <stdlib.h>

int main()
{
   1 || puts("Hello\n");
   0 || puts("Hi\n");
   1 && puts("ROFL\n");
   0 && puts("LOL\n");

   exit( 0 );
}

Este código generará:

Hola
ROFL

Usar INT (3) para establecer el punto de interrupción en el código es mi favorito de todos los tiempos

Mi característica "oculta" favorita de C es el uso de% n en printf para volver a escribir en la pila. Normalmente printf muestra los valores de los parámetros de la pila en función de la cadena de formato, pero% n puede escribirlos de nuevo.

Consulte la sección 3.4.2 aquí . Puede provocar muchas vulnerabilidades desagradables.

Comprobación de suposiciones en tiempo de compilación usando enumeraciones: ejemplo estúpido, pero puede ser realmente útil para bibliotecas con constantes configurables en tiempo de compilación.

#define D 1
#define DD 2

enum CompileTimeCheck
{
    MAKE_SURE_DD_IS_TWICE_D = 1/(2*(D) == (DD)),
    MAKE_SURE_DD_IS_POW2    = 1/((((DD) - 1) & (DD)) == 0)
};

Gcc (c) tiene algunas características divertidas que puede habilitar, como declaraciones de funciones anidadas y la forma a?: B del operador?: Que devuelve a si a no es falso.

Descubrí recientemente 0 bitfields.

struct {
  int    a:3;
  int    b:2;
  int     :0;
  int    c:4;
  int    d:3;
};

que dará un diseño de

000aaabb 0ccccddd

en lugar de sin el: 0;

0000aaab bccccddd

El campo de ancho 0 indica que los siguientes campos de bits deben establecerse en la siguiente entidad atómica ( char)

Macros de argumento variable de estilo C99, también conocido como

#define ERR(name, fmt, ...)   fprintf(stderr, "ERROR " #name ": " fmt "\n", \
                                  __VAR_ARGS__)

que se usaría como

ERR(errCantOpen, "File %s cannot be opened", filename);

Aquí también utilizo el operador stringize y la concatenación constante de string, otras características que realmente me gustan.

Las variables automáticas de tamaño variable también son útiles en algunos casos. Estos se agregaron en n99 y se han admitido en gcc durante mucho tiempo.

void foo(uint32_t extraPadding) {
    uint8_t commBuffer[sizeof(myProtocol_t) + extraPadding];

Termina con un búfer en la pila con espacio para el encabezado del protocolo de tamaño fijo más datos de tamaño variable. Puede obtener el mismo efecto con alloca (), pero esta sintaxis es más compacta.

Debe asegurarse de que extraPadding sea un valor razonable antes de llamar a esta rutina, o terminará volando la pila. Tendría que verificar los argumentos antes de llamar a malloc o cualquier otra técnica de asignación de memoria, por lo que esto no es realmente inusual.