Algunos comentarios:

scanf(" \n%d",&dim);

En la cadena de formato " \n%d" no es necesario utilizar " \n" ya que la función lo primero que hace es descartar el espacio blanco (tabulador, avance de linea, etc). Solo es necesario cuando se utilizan los especificadores "%c" y "%[]" ya que con ellos el descarte no sucede.

scanf (" \n%d",&dim);
 
/* ... */
 
char matriz[dim][dim];

Si van a utilizar un array declarado en esa forma hay que asegurarse de que el compilador soporte el estándar C99 y se compile en ese modo (a veces sucede).

char matriz[dim][dim];
 
/* ... */
 
for (i = 1; i <= dim; i++){
   for (j = 1; j <= dim; j++){
      matriz[i][j] = '.';
      printf("%c ", matriz[i][j]);
   }
 
   printf("\n");
}

En C y C los indices de los arrays inician en 0 y terminan en N-1 donde N es el numero de elementos. Hay que cambiar el par de bucles a:

char matriz[dim][dim];
 
/* ... */
 
for (i = 0; i < dim; i++){
   for (j = 0; j < dim; j++){
      matriz[i][j] = '.';
      fputs(". ", stdout); /* Imprime ". " en la salida estandar */
   }
 
   printf("\n");
}

Un saludo

Yo al menos llevo un tiempito usándolos en el Code::Blocks sin problemas.


Sí, estoy de acuerdo contigo. Pero yo lo estoy haciendo "a conciencia", puesto que las líneas de i=0 y j=0 se rellenarán para la numeración de las casillas.

 Y la dimensión de la matriz en mi último post ya estaba corregida a dim+1. De todas formas, gracias nuevamente por la atención prestada.

Saluditos! .... ..

Pues la verdad que tienes razón y como simple ejercicio voy a rehacer el código usando funciones, o sea modular, para que no se repitan líneas de código más allá de las imprescindibles.

Y ahora que mathias_vg a publicado su código, posteo el mío. Y como una imagen vale más que mil palabras ahí va:

   

Observar que he tenido en cuenta el "detallito" de que si el usuario introduce por error una letra en lugar de un número no entre en un bucle.  

Conste que hay una dimensión de la matriz por usar, todo a su momento, como el tema del color. ¿Te animas a una partidita?:

#include <stdio.h>
#include <stdlib.h>
#include<locale.h>
 
 
/**************  FUNCIONES  **************/
char** asig_memoria( int dim_plus);
void tamanyo_consola (char **matriz,int dim_plus);
void jugada(char **matriz,int dim_plus,int jugador, int color_juego);
void imprimir(char **matriz,int dim_plus,int color_juego);
void comprobar_ganador (char **matriz , int jugador, int x, int y, int dim_plus, int color_jueg);
void ganador (char** matriz,int jugador, int dim_plus, int color_juego,int gana_empata);
void contador(int* cont,char** matriz,int jugador, int dim_plus, int color_juego);
void liberar_mem_matriz( char** matriz, int dim_plus);
void salir( char** matriz, int dim_plus);
 
/**************  FUNCION MAIN   **************/
 
int main()
{
    setlocale(LC_ALL, "Spanish");
    int color_juego=0,dim_plus=0;
    char d,**matriz;
    int i=0,j=0,dim=0,movimientos=0,k=0,jugador=1,gana_empata=0;
    printf("\n\n\tIngresa la dimensión del tablero de juego (4-10):");
    fflush (stdout);
    do
    {
        scanf ("%d",&dim);
        if (dim<4 || dim>10 )
        {
            printf("\n\n\t\tOpción no valida.\n\n\t\tIngresa la dimensión (4-10): ");
            fflush (stdout);
        }
 
        while (getchar()!='\n');
    }while (dim<4 || dim>10);
    dim_plus=dim+1;
    matriz = asig_memoria( dim_plus );
    for (i=1;i<dim_plus;i++)
        for (j=1;j<dim_plus;j++)
            matriz[i][j]=' ';
    tamanyo_consola (matriz, dim_plus);
    imprimir( matriz, dim_plus, color_juego);
    while (movimientos<=(dim*dim))
    {
        jugada( matriz, dim, jugador, color_juego);
        imprimir( matriz, dim_plus, color_juego);
        if (jugador==1)
            jugador=2;
        else
            jugador=1;
        movimientos++;
        if (movimientos==dim*dim)
            ganador (matriz,jugador,dim_plus,  color_juego,gana_empata);
    }
    system("PAUSE");
    return 0;
}
/**************  FUNCION JUGADA  **************/
void jugada(char **matriz,int dim_plus,int jugador,int color_juego)
{
    int x=0,y=0,flag=0;
    char simbolo[]={'X','O'};
    do
    {
        do
        {
            flag=0;
            printf("\nJUGADOR %d (%c): ",jugador,simbolo[jugador-1]);
            fflush (stdout);
            scanf ("%d",&y);
            while (getchar()!='\n');
            if (y<1 || y>dim_plus)
                puts("Opción no valida.\nIngresa (4-10)");
        }while(y<1 || y>dim_plus);
        for (x=dim_plus;x>=0;x--)/*<==este for es mejorable*/
        {
            if (matriz[x][y]!=' ' && x!=0)
                continue;
            else if (x==0)
            {
                puts("¡Ya se llego al limite!.\nIntroduzca otro valor.");
                flag=1;
            }
            else
            {
                matriz[x][y]=simbolo[jugador-1];
                break;
            }
        }
    }while (flag==1);
    comprobar_ganador (matriz,jugador,x, y,dim_plus, color_juego);
}
/**************  FUNCION TAMAÑO DE LA CONSOLA  **************/
void tamanyo_consola (char **matriz,int dim_plus)
{
    char tamanyo_consola2[80];
    int tam_x=0,tam_y=0;
    tam_x=3.8*dim_plus; /* con estos valores puedes*/
    tam_y=2*dim_plus ;/*cambiar el tamaño de la consola*/
    sprintf(tamanyo_consola2, "MODE %d,%d", tam_x, tam_y);
    system(tamanyo_consola2);
    system ("cls");
}
/**************  FUNCION ASIGNACION DE MEMORIA  **************/
char **asig_memoria(int dim_plus )
{
    int i;
    char** matriz;
    matriz = malloc( dim_plus * sizeof *matriz );
    for( i = 0; i < dim_plus; ++i )
         matriz[i] = malloc( dim_plus * sizeof **matriz );
   return matriz;
}
/**************  FUNCION IMPRIMIR  **************/
void imprimir(char **matriz,int dim_plus,int color_juego)
{
    int i=0,j=0;
    system ("cls");
    for (i=0;i<dim_plus;i++)
    {
        for (j=1;j<dim_plus;j++)
        {
            if (i==0)
                {
                    printf ("[%d] ",j);
                    fflush (stdout);
                }
 
            else
                {
                    printf ("(%c) ",matriz[i][j]);
                    fflush (stdout);
                }
        }
        puts("");
    }
}
/**************  FUNCION COMPROBAR GANADOR  **************/
void comprobar_ganador (char **matriz , int jugador, int x, int y,int dim_plus,int color_juego)
{
    int k=1,cont=1;
    for (k=1;k<5;k++)
    {
        if ( x+k <= dim_plus && y+k <= dim_plus && matriz[x][y]==matriz[x+k][y+k])
            contador (&cont, matriz,jugador,dim_plus,  color_juego);
        else
            break;
    }
    for (k=1;k<5;k++)
    {
        if ( x+k > 0 && y+k > 0 && matriz[x][y]==matriz[x-k][y-k])
            contador (&cont, matriz,jugador,dim_plus,  color_juego);
        else
            break;
    }
    cont=1;
    for (k=1;k<5;k++)
    {
        if ( x+k <= dim_plus && y+k > 0 && matriz[x][y]==matriz[x+k][y-k])
            contador (&cont, matriz,jugador,dim_plus,  color_juego);
        else
            break;
    }
    for (k=1;k<5;k++)
    {
        if ( x+k > 0 && y+k <= dim_plus && matriz[x][y]==matriz[x-k][y+k])
            contador (&cont, matriz,jugador,dim_plus,  color_juego);
        else
            break;
    }
    cont=1;
    for (k=1;k<5;k++)
    {
        if ( x+k <= dim_plus && matriz[x][y]==matriz[x+k][y])
            contador (&cont, matriz,jugador,dim_plus,  color_juego);
        else
            break;
    }
     cont=1;
     for (k=1;k<5;k++)
    {
        if ( y+k <= dim_plus && matriz[x][y]==matriz[x][y+k])
            contador (&cont, matriz,jugador,dim_plus,  color_juego);
        else
            break;
    }
    for (k=1;k<5;k++)
    {
        if (y+k > 0 && matriz[x][y]==matriz[x][y-k] )
            contador (&cont, matriz,jugador,dim_plus,  color_juego);
        else
            break;
    }
}
/**************  FUNCION LIBERAR MEMORIA  **************/
void liberar_mem_matriz( char** matriz, int dim_plus )
{
   int i;
   for( i = 0; i < dim_plus; ++i )
      free( matriz[i] );
   free( matriz );
}
/**************  FUNCION CONTADOR   **************/
void contador(int* cont,char** matriz,int jugador, int dim_plus, int color_juego)
{
    int gana_empata=1;
    *cont=+*cont+1;
    if (*cont==4)
    {
        imprimir( matriz, dim_plus+1, color_juego);
        ganador (matriz,jugador,dim_plus,  color_juego,gana_empata);
    }
}
/**************  FUNCION GANADOR   **************/
void ganador (char** matriz,int jugador, int dim_plus, int color_juego,int gana_empata)
{
    if (gana_empata==1)
        printf ("Ganó el JUGADOR %d\n",jugador);
    else if (gana_empata==0)
        puts("EMPATE");
    else
        puts("¡ERROR!");
    puts ("Hasta lueguito.");
    salir( matriz, dim_plus );
}
/**************  FUNCION SALIR  **************/
void salir( char** matriz, int dim_plus )
{
    int i;
    for( i = 0; i < dim_plus; ++i )
        free( matriz[i] );
    free( matriz );
    system ("pause");
    exit (0);
}
/**************  FIN  **************/
 

Próximamente habrán más novedades/variantes del /los juegos, tanto del Conecta-4 como del 4 en línea.

Por supuesto que serán bienvenidas las críticasy/o sugerencias.

Ya adelanto que la intención es que tenga color y que se pueda elegir entre seguir jugando o salir. Detallitos que espero hagan más sugerente el/los jueguitos.

Y sí, ya sé que lo he "complicado" con tanta función pero de eso iba el "envite" deKaL3o .

Saluditos!.

Ya sabía que tarde o temprano te darías cuanta por ti mismo. Se debe a que el caracter, no utilizado porque el scanf no lo reconoce, ya que el espera un int, se queda en el bufer y en la próxima llamada al scanf éste toma automáticamente el valor del carcater que quedo en el bufer  y y así sucesivamente  entrando por ello en un bucle.

Fíjate e los detalles de mi código:

do
    {
        scanf ("%d",&dim);
        if (dim<4 || dim>10 )
        {
            printf("\n\n\t\tOpción no valida.\n\n\t\tIngresa la dimensión (4-10): ");
            fflush (stdout);
        }
 
        while (getchar()!='\n'); /*<==limpio el buffer e impido entrar en un bucle*/
    }while (dim<4 || dim>10);

Eso en los scanf de tipos numéricos, no hace falta cuando son de tipo char.


Saluditos! .... ..

Si sólo fuera un caracter podrías hacer uso de atoi, y aún así habría que añadir la condición de >0 y <15, pero como ves el "15" no es un caracter sino una cadena, con lo que no valdría el uso de dicha función y, en principio lo que se me ocurre a bote proto, sería  usar una función como "strol". Pero se me hace difícil entender que no uses getchar, que es una función muy usada de la librería stdio y, a cambio, te metas con funciones de la librería string que conllevan más cosas para lograr el objetivo.

Usa getchar.

Es más, en varios compiladores -e.j. Dev-C++- es una función que se aprende al tiempo que el uso de main o printf, pues si no la ponen al final del código el programa se ejecuta y se cierra de un golpe y, en ese caso, se usa getchar "como freno" para "ver" la consola antes de que ésta se cierre.


Saluditos!.