Dev - C++ - ayuda con un programa

int main(){

int k, l, m=5, n;
int *c1, *c2;

cout<&;Cuantas filas quieres: ";
cin>>n;
clrscr();
cout<<1<<endl;
c1=new int[4];
c1[0]=0; c1[0]=1; c1[0]=1; c1[0]=1;
cout<<c1[1]<<" "<<c1[2]<<" "<<endl;
for(k=0; k<n-2; k++, m++){
c2=new int[m];
c2[0]=0; c2[m-1]=0;
for(l=1; l<m-1; l++){
c2[l]=c1[l]+c1[l+1];
cout<<*c2<<" ";
}
cout<<endl;
c1=new int[m];
for(l=0; l<m; l++){
c1[l]=c2[l];
}
}
getch();
return 0;

}
</quote>

<quote>
int k, l, m=5, n;
int *c1, *c2;</quote>
les explicare como se supone q funciona la prueba de escritorio:
empezamos con 3 variables contador: "k, l y m" y una para ingresar el numero de filas q despliega el programa: "n".

*c1 y *c2 son vectores.
<quote>
cout<<"Cuantas filas quieres: ";
cin>>n;
clrscr();
cout<<1<<endl;</quote>
una vez q ingresamos el numero de filas para mostrar, limpio la pantalla con clrscr(); y luego mando un cout q me despliega el primer numero de la piramide; "1". Hasta esa instruccion, el programa debe mandar:
----------
1
----------
<quote>
c1=new int[4];
c1[0]=0; c1[0]=1; c1[0]=1; c1[0]=1;
cout<<c1[1]<<" "<<c1[2]<<" "<<endl;
</quote>
con la instruccion new, convierto a *c1 en un vector de 4 posiciones, a las cuales luego les asigno el valor de [0][1][1][0], y luego despliego solo los dos unos, y entonces el programa deberia de escribir:
------
1
1 1
-----
<quote>
for(k=0; k<n-2; k++, m++){
</quote>
a partir de aqui, el programa entra a un ciclo para repetir la operacion el numero de filas q se desea mostrar: n-2 por que ya ha mostrado 2 (aun no se como no mostrar las primeras dos :p)

<quote>
c2=new int[m];
c2[0]=0; c2[m-1]=0;
for(l=1; l<m-1; l++){
c2[l]=c1[l]+c1[l+1];
cout<<*c2<<" ";
</quote>
con este ciclo, c2 lo convierto en un vector de tamaño 1+ grande que c1, le asigno 0 a los extremos, y luego entra en un subciclo que asigna a las casillas de en medio los valores del vector anterior, ejem:
VECTOR *C1=[0][a][b][0]
VECTOR *C2=[0][0+a][a+b][b+0][0]
por lo que quedaria asi:
[0][1][1][0]
[0][1][2][1][0]

ya con el cout, solo despliego los numero diferentes de ceroy entonces el programa queda asi:
---------
1
1 1
1 2 1
--------

<quote>
cout<<endl;
c1=new int[m];
for(l=0; l<m; l++){
c1[l]=c2[l];
</quote>

por ultimo, con el cout me salto a la linea q sigue; luego convierto el vector c1 a tamaño igual a c2, y con el ciclo copio c2 a c1, para q los dos vectores sean iguales, para que cuando se reinicie el ciclo, empieze como
[0][1][2][1][0].
entonces empieza el cliclo y c2 es de tamaño 6 y queda
[0][1][3][3][1][0]
etc, hasta que el ciclo principal llegue a "n" y sea el tamaño de filas.

el probelma es que cuando corre el programa me manda una señal asi:
--------
1
451885215 0
0 0 0
0 0 0 0
0 0 0 0 0
---------
no tengo idea por que, si a me parece que el algoritmo esta bastante claro y esta bien codificado; si me pueden ayudar muchas gracias por que esto es algo frustrante, el no saber cual es el problema, igual y es mi procesador o yo que se :(

Buenas. Probare el codigo que has publicado y vere cual es el problema, para mañana te dare una respuesta. Hasta luego.

Aca te dejo el codigo que hice en base al que dejastes en el foro, hice uno nuevo porque se me hizo mas facil. Te recomiendo que cuando crees elementos dinamicamente los elimines tambien con la palabra delete para asi evitar dejar en memoria elementos innecesarios.

El codigo fue diseñado usando Dev C++, corre bien y sin problemas, creo que esto era lo que querias hacer, le coloque comentarios (como puedes ver) para hacerlo mas entendible. Espero te sea de ayuda.

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

int main()
{
//creo las variables que controlaran el programa
int filas, contador, limite = 3;

//estas variables son los arreglos dinamicos (el tamano se crea cuando se ejecuta)
//para que se pueda realizar esto las variables deben ser punteros, en este caso
//son apuntadores a enteros ya que se van a guardar numeros
int *c1, *c2;

printf("Introduzca la cantidad de filas: ");
scanf("%d", &filas);

//con esta variable recorrere los arreglos
contador=0;

//creo el primer arreglo y le defino el tamano
c1 = new int[limite];

//defino los valores iniciales
c1[0]=0; c1[1]=1; c1[2]=0;

//hago un ciclo que se repetira mientras haya una o mas filas
while(filas>0)
{
//creo un segundo arreglo dinamico en el cual se colocaran los valores
//que se desean mostrar, este arreglo es necesario ya que el otro sera
//modificado mientras se ejecuta la aplicacion
c2 = new int [limite];

//establezco que siempre el primer numero del segundo arreglo sera el
//primer numero del primer arreglo
c2[0]=c1[0];

//con este ciclo se recorrera y agregara valores al arreglo c2
//comienza en la posicion 1 porque ya se establecio el valor de
//la posicion 0
for(contador=1; contador<limite-1; contador++)
{
c2[contador]=c1[contador-1]+c1[contador];
printf("%d ", c2[contador]);
}
printf("\n");
//para evitar que el valor contenido en la ultima posicion sea basura
//lo establezco en 0
c2[contador]=0;

//como el arreglo se creo dinamicamente y se va a estar creando uno nuevo
//en cada repeticion es necesario eliminar el anterior de memoria, asi se
//evita consumir muchos recursos
delete c1;

//incremento el limite porque la siguiente fila tendra un numero mas que
//la anterior
limite++;

//creo nuevamente el arreglo c1 pero ahora tiene un nuevo tamano que es
//un valor mas que el que tenia antes, es decir, si antes ocupaba cuatro
//espacios, ahora ocupara cinco.
c1 = new int[limite];

//hago un ciclo para volver a colocar los valores en el arreglo c1, como
//se trabajara con los valores que se tenian anteriormente y estos estan
//en c2, lo que se hace es recorrer c2 y colocar esos valores en c1.
for(contador=0; contador<limite-1; contador++)
{
c1[contador]=c2[contador];
}
//como c1 es un valor mas grande que c2, se establece el valor de la
//ultima posicion en 0. Hay que recordar que cuando de dale del ciclo
//anterior la variable contador valdra limite-1, y esta es la nueva
//posicion
c1[contador]=0;

//elimino c2 de memoria porque si se repite el ciclo se volvera a crear
//con el nuevo tamano
delete c2;
//voy decrementando el numero de filas porque sino el ciclo nunca se acaba
filas--;
}

system("pause");
return 0;
}