Una expresión como esta:

a[i] = i++;

Tiene un resultado indefinido, explicando por partes:

1) Los puntos de secuencia. Salvo los operadores '&&', '||', ',' y '?:' el siguiente punto de secuencia se indica por el terminador de sentencia ';'. Un ejemplo:

alguna_expresion (1); /* (1)  marca el siguiente punto de secuencia */

2) Todo efecto lateral (por ejemplo el generado por los operadores unarios ++ y --) se aplicara en algún momento antes del siguiente punto de secuencia.

3) Dada la mentada expresión:

a[i] = i++;
 (1)  (2)

Y considerando lo anterior esta puede ser evaluada en cualquiera de las siguientes formas:

* La expresión (2) se evalúa primero, a continuación aplica el efecto lateral y por ultimo se evalúa (1).
* La expresión (2) se evalúa primero, a continuación se evalúa (1) y por ultimo aplica el efecto lateral.
* La expresión (1) se evalúa primero, a continuación se evalúa (2) y por ultimo aplica el efecto lateral.

Cualquiera que suceda es valida (y por ello la recomendación de evitar expresiones cuyo resultado es indefinido).

----

Otra historia son expresiones del tipo:

i = i++;

Estas son ilegales ya que se modifica un objeto (en este caso la variable "i") en mas de una ocasión entre puntos de secuencia (la asignación mas el efecto lateral).

Un saludo

No (por el desplazamiento). Para explicarlo mejor considerando que el numero de iteraciones y el desplazamiento esta dado por "magic numbers":

unsigned despliegaMascara = 1 << 31;
 
/* ... */
 
for(c = 1; c <=	32; c++) ...

Si el numero de bits del tipo unsigned int es:
A) Mayor (por ejemplo 64) entonces solo se procesa una parte de los bits.
B) Menor (por ejemplo 16) entonces el desplazamiento "1 << 31" causara que el programa reviente ya que el segundo operando debe ser mayor que cero y menor que el numero de bits del objeto.

Un saludo

Un problema con ese programa es asumir que el tipo unsigned int esta constituido por 32 bits (si son mas el resultado es incorrecto, si son menos el programa reventara por el desplazamiento).

Una mejor aproximación consiste en utilizar el operador sizeof para obtener el numero de bytes y la macro CHAR_BIT para el numero de bits:

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
 
void imprimir(unsigned num);
 
int main(void)
{
   unsigned num;
 
   printf("Introduce un entero no negativo: ");
   fflush(stdout);
   if (scanf("%u", &num) != 1)
      return EXIT_FAILURE;
 
   imprimir(num);
 
   return EXIT_SUCCESS;
}
 
void imprimir(unsigned num)
{
   unsigned msb = 1U << sizeof(unsigned) * CHAR_BIT - 1;
   size_t i;
   size_t j;
 
   for (i = 0; i < sizeof(unsigned); i++){
      for (j = 0; j < CHAR_BIT; j++){
         putchar(num & msb ? '1' : '0');
         msb >>= 1;
      }
 
      putchar(' ');
   }
   putchar('\n');
}

Un saludo

Los errores que mencionas se generan porque tratas de utilizar los alias (solo necesitas uno) como si fueran nombres de variables.

Debe ser:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
/* 1) Se declara el tipo y su nombre alternativo (alias) */
struct coordenada {
   int x;
   int y;
};
typedef struct coordenada coord;
 
int main(void)
{
   /* 2) Se declaran las variables necesarias */
   coord a;
   coord b;
 
   /* 3) Lectura de datos */
   puts("Introduce la coordenada x1:");
   scanf("%d", &a.x);
   puts("Introduce la coordenada y1:");
   scanf("%d", &a.y);
 
   puts("Introduce la coordenada x2:");
   scanf("%d", &b.x);
   puts("Introduce la coordenada y2:");
   scanf("%d", &b.y);
 
   /* Calculo de la hipotenusa */
 
   return EXIT_SUCCESS;
}

Y si vas a imprimir en la salida estándar una cadena literal terminada en '\n' utiliza la función puts en lugar de printf. Por ultimo evita el uso de fflush(stdin), las razones de ello en el tema |Lo que no hay que hacer en C/C++. Nivel basico|.

Un saludo

Se puede calificar con const el tipo del segundo parámetro:

char coincidencia(const char letra, const char *diccionario) ...
 
/* O bien */
char coincidencia(const char letra, char const *diccionario) ...

Ya que ello afecta al objeto apuntado.

Supongo estabas pensando en "char * const diccionario" donde el calificador si es un problema.

Un saludo

Obtienes los dos puntos de alguna forma, a continuacion obtienes la hipotenusa del triangulo rectangulo con:

hipotenusa = sqrt(x * x + y * y);

Un saludo

Para imprimir las tablas en columnas en vez de filas solo tienes que invertir los bucles e imprimir un avance de linea después del bucle interno. Se deben cambiar a:

for (x = 1; x <= 10; x++){
   for (y = ti; y <= tf; y++){
      res = y * x;
      cout << " " << y << "*" << x << "=" << res;
   }
 
   cout << endl;
}

Un saludo

Tienes que leer con mas cuidado el tema, eso lo respondí en mi primer mensaje:
Antes de utilizar rand y srand se debe incluir <stdlib.h>, antes de time <time.h>.


Un saludo

Si encuentras eso realmente molesto abre un tema sobre ello en el foro Sugerencias y dudas sobre el Foro

Un saludo

Por favor no escribas el texto en mayúsculas, dificulta la lectura y en foros como este equivale a gritar.

----

Tienes tres casos distintos, en el primero:

typedef struct coordinate {
   int x;
   int y;
} Coordinate;
 
 
int main()
{
   Coordinate c[N];
}

Declaras la estructura "struct coordinate" y su alias "Coordinate", puedes utilizar cualquiera de los dos para la declaración, esta se realiza en la función main: "c" es un array de N elementos de tipo "Coordinate".

En el segundo:

typedef struct {
   int x;
   int y;
} Coordinate;
 
int main()
{
   Coordinate c[N];
}

La estructura es anónima (sin nombre, para ser exactos, sin etiqueta). De nuevo la declaración se realiza en la función main y aquí solo puedes utilizar el alias.

El tercero:

typedef struct Coordinatei {
   int x;
   int y;
} c[N];
 
int main()
{
    struct coordinate c[N];
}

Es mas complicado y no es valido ya que:
1) Se declara la estructura "struct Coordinatei".
2) Se declara el alias "c" como equivalente a "struct Coordinatei [N]".
Ya que no hay declaración de "struct coordinate" tu compilador debe generar un mensaje de error.

Por ultimo y solo para redondear puedes utilizar "c" como el tipo para declarar un array, por ejemplo:

/* Forma usual */
struct Coordinatei a[N];
 
/* Utilizando el alias */
 c b;
 

En ambas declaraciones el tipo es el mismo: array de N elementos de tipo "struct Coordinatei", la primera utiliza la forma usual y la segunda el alias.

Un saludo