Bueno eferion, aquí la respuesta es cuestión de gustos. Ambas soluciones son funcionales, por supuesto que usando plantillas STL el código es más breve y fácil para el programador, pero por otra parte hay cierta "sobrecarga", al invocar reiterativamente otras clases y sus métodos.

Claro que las clases STL están optimizadas para aumentar la velocidad de ejecución, pero mi intención aquí fue proponer una clase de matrices que usara sólo los más métodos más básicos, y sin invocar a otras clases. Pero al fin ahora tenemos dos enfoques diferentes para el mismo problema ...

Claro, el "desbordamiento de buffer" es un problema típico en la programación, y que por supuesto debemos evitar.

Para C (en C++ el tamaño del arreglo se ajusta automáticamente) una solución sería usar fgets(char *s, int size, FILE *stream), que limita la cantidad de caracteres leídos a size - 1 (se resta uno porque la última posición está reservada para el nulo de terminación). En stream hemos de poner stdin para que lea de la entrada estándar (hay unas consideraciones con fgets() que explicaré al final)

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
int getInt(char *);
int isInt(char * s);
 
int main( ) {
 
	int x;
	char msg[] = "Intro numero: ";
 
	printf("Numero es: %d\n", getInt(msg));
}
 
int getInt(char *msg) {
 
	#define N 3
	char s[N + 1];
	int i; 
	char clean_return;
 
	do {
		printf("%s", msg);
		fgets(s, N + 1, stdin);
 
		/* reemplazar '\n' (si se encuentra) por '\0' */
		i = -1;
		clean_return = 1;
		while ( s[++i] != '\0' )
			if ( s[i] == '\n' ) {
				s[i] = '\0';
				clean_return = 0;
				break;
			}
 
		/* si no se pasó '\n' al arreglo, limpiarlo del bufer de entrada */
		if ( clean_return ) getchar();
	} while( *s == '\0' || !isInt(s) );
 
	return atoi(s);
}
 
int isInt(char * s) {
 
	int i = -1; 
 
	while ( s[++i] != '\0' ) {
		if( !isdigit(s[i]) )
			return 0;
	}
	return 1;
}

El programa pide al usuario un cadena, que es evaluada como entero siempre y cuando todos sus caracteres sean numéricos. De lo contrario, pide de nuevo. Al final imprime lo que leyó, para verificar.

Como ya se explicó, si por ejemplo declaras un arreglo char[] de N+1 caracteres, entonces fgets() lee como mucho N caractares. Si el fin de línea se encuentra dentro de esos N caracteres (si la cadena tiene una longitud menor N) entonces el fin de linea '\n' es pasado al arreglo. De lo contrario, (si la longitud de la cadena es mayor o igual a N) el '\n' no se pasa al arreglo y queda "pendiente" en el flujo de entrada del teclado. Por eso es necesario eliminarlo con getchar()

Se podría hacer una modificación al isInt() con el objeto de admitir un único carácter de signo '-' al inicio de la cadena, así permitir números negativos.

El código propuesto está en C, lo que implementa una solución más "básica" que C++. Creo que una simple operación de lectura de datos por teclado no exige invocar el complejo modelo de objetos de E/S de C++ ..... (bueno aunque de ahí en adelante no opino más, ello depende del gusto del programador)

Interesante la simplificación de leosansan, ventajas del trabajo en equipo. Te cuento que soy de Guayana, en el sur de Venezuela, y aquí consideramos como prócer a Manuel Carlos Piar, de quién se dice era hijo de Canarios (y Bolívar desarrolló una infame envidia y rivalidad contra él, mandándolo a fusilar). Piar fue un formidable oficial que combió técnicas de estrategia, en oposición a la lucha de burda de carnicería acostumbrada por entonces, y así llegó invicto en el campo de batalla hasta el final de sus días.

Eferion, gracias, realmente había olvidado liberar la memoria (sorry).

Ahora otra vez leo, me parece interesante tu simplificación del código, pero explícamente la aritmética usada de 12, 18, 36, etc ..... No entiendo esas fórmulas, y creo que también hubiera sido bueno comentariar esa explicación en el programa, los demás no somos adivinos jejejeje (broma)

Amigos, no era mi intención ponerme por encima de otros, pues tampoco quiero que ese rasgo caracterice mi personalidad.

Hace rato comenté que cuando era más joven yo era impulsivo, pero eso fue un error y quiero darlo por superado.

Mi comentario vino al caso pues siendo mi profesión u ocupación, y dada la naturaleza o tipo del problema, quise dar mi aporte en la materia del conocimiento que atañe a este ejercicio. Y siempre ha sido así en post similares que tratan temas matemáticos (operaciones con bases numéricas, resolución de ecuaciones, etc).

En fin, sólo quise hacer unos comentarios para nutrir la "base de información" disponible por todos para la resolución del problema. Y por supuesto que yo NO HARÍA estos comentarios si se tratase de ejercicios o temas de otra naturaleza: trato de limitarme a mi ámbito y no invadir el de los demás. Considero que esa es la base filosófica del respeto ajeno, tan necesario en este mundo.

La otra vez estaba pensando en compartir un código que hice hace tiempo para dibujar por consola (con asteriscos y líneas) la gráfica de una función. En coordenadas polares, y con algunas ecuaciones particulares tomadas de los libros, se producen una gráficas bellísimas (lissajous, mariposas, etc). Me gustaría poder hacerlo sin herir la sensibilidad de nadie aquí en el foro.

¿Saben? Me entristece mucho esa persistente rivalidad entre ingenieros y matemáticos, que se puso de manifiesto en un comentario que me hicieron. Y para ver que las cosas no son siempre lo que paracen, en realidad yo también soy ingeniero, pero estudioso de las matemáticas por afición. En realidad, también me gustan el ajedrez y otras cosas, jeje. Enseño matemáticas como mi trabajo, de eso me gano la vida. Una vez en una conferencia sobre métodos numéricos el ponente (que sí era un Matemático de carrera, al contrario que yo) salió con el bendito tema: los ingenieros esto y aquéllo .... Y yo por supuesto no le respondí, porque ya me tienen cansado con ese asunto .

No se, es una rivalidad que no debería existir. Antes no era así, recordemos que Pascal fue pionero en el diseño de una máquina de calcular, que luego fue perfeccionada por también matemático Leibniz. El Álgebra, la Aritmética y la Lógica siempre han estado ligadas a la Computación, y no se realmente por qué ahora existe ese divorcio y esa competencia. En la antiguedad, muchos intelectuales eran integrales e indagaban en varias áreas. Descartes es conocido por filósofo, pero también como autor del "plano cartesiano". Newton fue conocido por físico, pero sorprendentemente también fue alquimista. Y Leonardo, inventor, ingeniero y artista.

Pero en fin muchachos, reflexionando sobre la realidad actual del mundo está claro que por sobre todas las cosas: Hagamos la Paz y no la Guerra.   

COOL !!!!!!!!!!!

Mira, tengo que hacerle unos ajustes para correrlo en Linux pues como sabes no sirve windows.h. En particular, cambiar los métodos color() y gotoxy() que controlan aspectos de la terminal, para que funcionen en base a secuencias de escape.

Por cierto una curiosidad, ¿por qué no codificaste esos métodos basados en servicios de BIOS, que es como creo están implementados en conio (hasta donde tengo recuerdo, con los viejos compiladores de Borland 16bits y 32bits que usé alguna vez para Windows)?

Leo, se me ocurre que una forma de ampliar el programa, sería habilitar las teclas de flecha, para uno poder conducir la pelota por en medio de los obstáculos, algo como mini-pinball. Me ofrecería a hacer algo de esa parte, puesto que ya tú ya hiciste lo primero, jeje (complementarnos en vez de competir) ....

Bueno ..... creo que ya hemos dado una tremenda cantidad de opciones al autor del post sobre cómo resolver su problema.

Lástima que él no haya seguido escribiendo, y al final terminamos agarrándonos el tema para nosotros, jeje 

Leo, ya se que él dijo tres fichas, pero no se en qué posición deben ir. Por eso dejé a potestad del autor del post poner las fichas en su lugar  

Y leosansan coincido contigo en lo bueno de la sana competencia, sin hacer la violencia.

Y disertando contigo sobre el tema, pienso (no se si discrepo contingo) que no hay que ser tan extremista en el uso de lo básico, ¿no has considerado positivo de uso de macros, constantes y ficheros de cabecera? Hará tu programa más flexible y configurable, además tendrá la fácil posibilidad de ampliarse o modificarse. Los proyectos profesionales hacen uso de este recurso, por ejemplo los nombres que usé los tomé del fichero de cabecera de la biblioteca ncurses, y supongo que lo mismo ocurre con conio.

No me gusta ser "talibán" o extremista [lo fui cuando era más joven, y creo que fue un error  ]. Por ejemplo hay programadores de C que son "linuxeros" exclusivos y hacen sus programas dependientes de Linux, discriminando a los usuarios Windows. Otros lo mismo pero al revés. Aunque yo prefiero Linux, trato de hacer mis programas de C de modo que sean compatibles en ambos sistemas, soy consciente de que el 90% o más de los usuarios del mundo usan Microsoft y eso hay que respetarlo.

No los hago compatible también para Apple porque no la conozco, no tengo Mac (es muy caro en mi país, jeje  )

Y para cerrar, aunque no es el motivo de este foro, cuento que mi país (Venezuela) está tomado actualmente por la violencia, pido a todos hagan el deseo de que esto cese, y retornen la Justicia y la Libertad a mi tierra. España pasó por Franco, Chile por Pinochet, ... etc, todos los ciudadanos hispanos han padecido el totalitarismo (de derecha o de izquierda, que al fin resulta lo mismo) y deberían poder comprender mis palabras ...

Sería muy interesante hacer la animación de la pelota rebotando (refrescamiento de pantalla cuadro a cuadro y con pausa entre ellos), al estilo de un videojuego 

¿alguien se atreve?

Buenos días, lamento llegar un poco tarde, tampoco ser entrometido (como me acusaron en otro post  )

Inspirándome un poco en el enfoque de rir7360 que "centró" el rombo, es decir tomó los índices de -N a N, en lugar de 0 a 2*N, quiero aportar una función que dibuja un rombo general con cualquier número de líneas (impar positivo) dado.

El main() pide al usuario la cantidad de líneas del rombo, pero esto esta interfaz se puede modificar. Lo importante es el código de la función rombo() que gracias al enfoque de "centrar" los valores no requiere dividir entre la parte de arriba y la parte de abajo, ni entre derecha e izquierda, jeje.

Resultado, con 9 líneas:

    *   
   ***   
  ***** 
 *******
*********
 *******
  ***** 
   ***   
    *   


Básicamente lo que hacemos es calcular el "punto medio" p de N (redondeo por exceso de N/2), para el caso N=9 sería p=5. Luego recorremos tanto i como j desde -p+1 hasta p-1, o sea, desde -4 hasta 4. El asterisco se imprime si abs(j) < p - abs(i), y esto dibuja el rombo de manera correcta, tanto en su parte superior como la inferior. El código:

 #include <stdio.h>
 #include <stdlib.h>
 
 void rombo (int N);
 
 int main(void) {
 
	int N;
 
	printf("Ancho del rombo: ");
	scanf("%d", &N);
 
	/* limpia la entrada estandar por caracteres no leidos */
	while ( getchar() != '\n' )
		;
 
	/* comprueba N impar y positivo */
	if ( N > 0 && (N % 2) == 1) 
		rombo( N );
	else
		printf("N debe ser impar positivo\n");
 
	return 0;
}
 
/* Imprime un rombo de N lineas */
void rombo (int N) {
 
	int i, j, p;
 
	p = (int) N / 2 + 1;		/* punto medio ente 1 y N */
	for (i = -p + 1; i <= p - 1; i++) {
		for (j = -p + 1; j <= p - 1; j++) 
			if ( abs(j) < p - abs(i) ) 
				putchar('*');
			else
				putchar(' ');
		putchar('\n');
	}
}

"Yo, en particular, estoy muy contento con tus aportes ya que la mayoría de los expertos lo son más de C++ y a mí me interesa más el C puro y duro"

Jejeje, pues sí, es un dicho que entre más bajo el nivel más duro es el programador, jeje. De hecho me impongo como costumbre personal tratar de hacer los programas en C puro, salvo que sea estrictamente necesario usar C++ (por ejemplo si se requieren clases).

Ya tengo la respuesta (y creo que me quedó cool ). Bueno, es cuestión de probar con estos nuevos simbolitos, y tener paciencia hasta "cuadrar" el resultado. Yo te recomendaría anabelangie, definir mnemónicos o nombres simbólicos para los códigos ASCII a usar, de esa forma se trabaja de manera estructurada, y el código es más fácil de comprender y modificar en el futuro.

Siguiendo más o menos la nomenclatura que pude escudriñar en el fichero de cabecera [ncurses.h (el equivalente Linux para conio.h), me "copié" los nombres:

#define ULCORNER 218      /* upper-left corner, esquina superior izquierda */
#define URCORNER 191      /* upper-right corner, esquina superior derecha */
#define LLCORNER 192      /* lower-left corner, esquina inferior izquierda */
#define LRCORNER 217      /* lower-right corner, esquina inferior izquierda */
#define VLINE    179      /* vertical line, linea vertical */
#define HLINE    196      /* horizontal line, linea horizontal (guion) */
#define TTEE     193      /* top-tee, letra 'T' apuntando hacia arriba */
#define RTEE     195      /* right-tee, letra 'T' apuntando hacia la derecha */
#define BTEE     194      /* bottom-tee, letra 'T' apuntando hacia abajo */
#define LTEE     180      /* left-tee, letra 'T' apuntando hacia la izquierda */
#define CROSS    197      /* crossover, cruz grande (de mayor tamaño que el signo '+') */
#define TOKEN    219      /* ficha o pieza */

y disculpen el inglés, es sólo para hacerlo más universal. Lo demás es modificar el printBoard para que el diseño te quede como quieres. Claro, es más laborioso que con '+', '|' y '-', y requiere muchos más caracteres para producir el resultado  ...

Los caracteres de la matriz A que sean distintos de un nulo '\0' y de un espacio se representarán como la ficha o TOKEN (ASCII 219). Queda la posibilidad de ampliar el programa para permitir varios diseños de fichas, según los caracteres simbólicos en A. El resultado:

┌───┬───┬───┬───┬───┬───┬───┬───┐
│ █ │ █ │ █ │   │ █ │ █ │   │ █ │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │   │   │ █ │   │   │ █ │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │   │ █ │   │ █ │   │ █ │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │ █ │ █ │ █ │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │   │ █ │ █ │   │ █ │ █ │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │   │   │ █ │ █ │ █ │ █ │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │ █ │ █ │ █ │ █ │ █ │ █ │
└───┴───┴───┴───┴───┴───┴───┴───┘


y el código fuente que lo produce:

#include <stdlib.h>
#include <stdio.h>
 
#define M 8
#define N 8
 
/* Definiendo mnemonicos para los simbolos ASCII */
#define ULCORNER 218		/* upper-left corner, esquina superior izquierda */
#define URCORNER 191		/* upper-right corner, esquina superior derecha */
#define LLCORNER 192		/* lower-left corner, esquina inferior izquierda */
#define LRCORNER 217		/* lower-right corner, esquina inferior izquierda */
#define VLINE    179		/* vertical line, linea vertical */
#define HLINE    196		/* horizontal line, linea horizontal (guion) */
#define TTEE     193		/* top-tee, letra 'T' apuntando hacia arriba */
#define RTEE     195		/* right-tee, letra 'T' apuntando hacia la derecha */
#define BTEE     194		/* bottom-tee, letra 'T' apuntando hacia abajo */
#define LTEE     180		/* left-tee, letra 'T' apuntando hacia la izquierda */
#define CROSS    197		/* crossover, cruz grande (de mayor tamaño que el signo '+') */
#define TOKEN    219		/* ficha o pieza */
 
void fillRow( char **, int, const char *);
void printBoard( char ** );
 
int main() {
 
	char **A;
	int i;
 
	/* Inicializa la matriz, y termina si ocurre error */
	if ( ( A = (char **) malloc ( M * sizeof(char *) ) ) == NULL )
		return -1;
	for (i = 0; i < M; i++ )
		if ( ( A[i] = (char *) malloc ( N * sizeof(char) ) ) == NULL )
			return -1;
 
	fillRow( A, 0, "xxx xx x" );
	fillRow( A, 1, "x  x  x " );
	fillRow( A, 2, "x x x x " );
	fillRow( A, 3, "xxxxx   " );
	fillRow( A, 4, "xx      " );
	fillRow( A, 5, "xx xx xx" );
	fillRow( A, 6, "x  xxxx " );
	fillRow( A, 7, "xxxxxxxx" );
 
	/* imprimir el tablero */
	printBoard( (char **)A ); 
 
	return 0;
}
 
/* Rellena la fila i de la matriz A con los elementos del vector x */
void fillRow( char **A, int i, const char *x) {
 
	int j;
 
	for (j = 0; j < N; j++)
		A[i][j] = x[j];
}
 
/* Imprime un tablero de 8x8, rellenando las casillas con los 
 * caracteres almacenados en la matriz A
 */
void printBoard( char **A ) {
 
	int i, j;
	char c, *s;
 
	printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", ULCORNER, 
		HLINE, HLINE, HLINE, BTEE,
		HLINE, HLINE, HLINE, BTEE,
		HLINE, HLINE, HLINE, BTEE,
		HLINE, HLINE, HLINE, BTEE,
		HLINE, HLINE, HLINE, BTEE,
		HLINE, HLINE, HLINE, BTEE,
		HLINE, HLINE, HLINE, BTEE,
		HLINE, HLINE, HLINE, URCORNER);
	for (i = 0; i < M; i++) {
		putchar(VLINE);
		for (j = 0; j < N; j++)
			if ( A[i][j] != '\0' && A[i][j] != ' ')
				printf(" %c %c", 219, VLINE);
			else
				printf("   %c", VLINE);
		if ( i < M - 1 )
			/* todas las lineas excepto la ultima */
			printf("\n%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", RTEE, 
				HLINE, HLINE, HLINE, CROSS, 
				HLINE, HLINE, HLINE, CROSS,
				HLINE, HLINE, HLINE, CROSS,
				HLINE, HLINE, HLINE, CROSS,
				HLINE, HLINE, HLINE, CROSS,
				HLINE, HLINE, HLINE, CROSS,
				HLINE, HLINE, HLINE, CROSS,
				HLINE, HLINE, HLINE, LTEE);
		else
			/* la linea final */
			printf("\n%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", LLCORNER, 
				HLINE, HLINE, HLINE, TTEE, 
				HLINE, HLINE, HLINE, TTEE,
				HLINE, HLINE, HLINE, TTEE,
				HLINE, HLINE, HLINE, TTEE,
				HLINE, HLINE, HLINE, TTEE,
				HLINE, HLINE, HLINE, TTEE,
				HLINE, HLINE, HLINE, TTEE,
				HLINE, HLINE, HLINE, LRCORNER);
	}
 
}[/tt]
 
 

---

Ah, por cierto, yo trabajo en consola de Linux, y para que me pudiera representar correctamente los símbolos tuve que poner la codificación "IBM850", no me sirvió ISO-5589-1 ni UTF-8. No se si en Windows será lo mismo ... ¿alguien sabe qué pasa con ésto?