Punto y coma

[@synthesize]

Estudiando métodos de ordenación, em quedé en Radix. Ví el código de ejemplo que ponene en Wikipedia para implementar, hasta ahí todo bien

Ví que en varias sentencias, ponían ; en una linea, siendo el único contenido de la misma. Pensaba que es un error, así que probé a compilar, pero funciona perfectamente. ¿Alguien me dice que hace ahí ese punto y coma?

Código (c) [Seleccionar] Expandir

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define NUMELTS 20

void radixsort(int x[], int n)
{
  int front[10], rear[10];
  struct {
    int info;
    int next;
  } node[NUMELTS];
  int exp, first, i, j, k, p, q, y;

  /* Inicializar una lista vinculada */
  for (i = 0; i < n-1; i++) {
    node[i].info = x[i];
    node[i].next = i+1;
  } /* fin del for */
  node[n-1].info = x[n-1];
  node[n-1].next = -1;
  first = 0; /* first es la cabeza de la lista vinculada */
  for (k = 1; k < 5; k++) {
    /* Suponer que tenemos números de cuatro dígitos */
    for (i = 0; i < 10; i++) {
      /*Inicializar colas */
      rear[i] = -1;
      front[i] = -1;
    } /*fin del for */
    /* Procesar cada elemento en la lista */
    while (first != -1) {
      p = first;
      first = node[first].next;
      y = node[p].info;
      /* Extraer el kâsimo dÁgito */
      exp = pow(10, k-1); /* elevar 10 a la (k-1)ésima potencia */
      j = (y/exp) % 10;
      /* Insertar y en queue[j] */
      q = rear[j];
      if (q == -1)
front[j] = p;
      else
node[q].next = p;
      rear[j] = p;
    } /*fin del while */

    /* En este punto, cada registro está en su cola basándose en el dígito k
       Ahora formar una lista única de todos los elementos de la cola.
       Encontrar el primer elemento. */
    for (j = 0; j < 10 && front[j] == -1; j++);
      ;
    first = front[j];

    /* Vincular las colas restantes */
    while (j <= 9) { /* Verificar si se ha terminado */
      /*Encontrar el elemento siguiente */
      for (i = j+1; i < 10 && front[i] == -1; i++);
;
      if (i <= 9) {
p = i;
node[rear[j]].next = front[i];
      } /* fin del if */
      j = i;
    } /* fin del while */
    node[rear[p]].next = -1;
  } /* fin del for */

  /* Copiar de regreso al archivo original */
  for (i = 0; i < n; i++) {
    x[i] = node[first].info;
    first = node[first].next;
  } /*fin del for */
} /* fin de radixsort*/


int main(void)
{
  int x[50] = {NULL}, i;
  static int n;

  printf("\nCadena de números enteros: \n");
  for (n = 0;; n++)
    if (!scanf("%d", &x[n])) break;
  if (n)
    radixsort (x, n);
  for (i = 0; i < n; i++)
    printf("%d ", x[i]);
  return 0;
}


[carlitos_jajajajaja]

cuando solo hay un punto y coma quiere decir sentencia vacia, o sea que literalmente ese punto y coma no hace nada

Supongo que es cuestion del estilo del codigo, lo hace para enfatizar - separar del resto del codigo los bucles terminados en punto y coma, seguramente como una forma de decir "Notese que este bucle no tiene ninguna otra sentencia asociada"

[@synthesize]

En caso de ser eso que dices, es la técnica mas rara para enfatizar que he visto en mucho tiempo XD

[nicolas_cof]

Al margen de que a mi tambien me parece una tecnica muy oscura ( oscura = rara ), cabe mencionar que no afecta en nada el uso de sentencias vacias ( ; ).

Salu10.

[do-while]

Es lo que se ha comentado hasta ahora. La primera y unaica vez que he visto codigo de este estilo, fue algo diferente. Aqui realizan el for sin cuerpo poniendo un punto coma justo despues de la estructra de repeticion, y luego añaden fuera del cuerpo, pero indexada, una unica sentencia vacia.

Yo normalmente utilizo la primera forma (el for sin cuerpo), pero en el que vi, dejaban el for como siempre y luego añadian en el cuerpo la sentencia vacia:

Código (c) [Seleccionar] Expandir


for(... ; ... ; ...)
   ; /* aqui la sentencia vacia */


Para gustos hay colores...

¡Saludos!