Mensajes

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <windows.h>

#define t Sleep(200)


void mostrar(char mapa[26][26]){
system ("cls");

    for(int y=0;y<25;y++)
    {
    for(int x=0;x<25;x++)
    {
    printf("%c",mapa[y][x]);
    //Sleep(1);
    }
    printf("\n");
    //Sleep(1);
    }
   
}

int main (){

char mapa[26][26]={
"0000000000000000000000000",
"1111110000000000000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"0000011100000000000000000",
"0000000100000000000000000",
"0000000100000000000000000",
"0000000110000000000000000",
"0000000011111100000000000",
"0000000000000100000000000",
"0000011111111100000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"1111110000000000000000000",
"1000000000000000000000000",
"1000000000000000000000000",
"1111111111111111000000000",
"0000000000000001000000000",
"0000000000000001111100000",
"0000000000000000000100000",
"0000000000000000111100000",
"0000000001111111100000000",
"0000000001000000000000000",
"0000000001000000011111110",
"0000000001111111110000000",
};


mapa[1][0]='X';//1.0 hacia la 1.5
mostrar(mapa);
t;


mapa[1][1]='X';//1.1
mostrar(mapa);
t;


mapa[1][2]='X';//1.2
mostrar(mapa);
t;


mapa[1][3]='X';//1.3
mostrar(mapa);
t;


mapa[1][4]='X';//1.4
mostrar(mapa);
t;


mapa[1][5]='X';//1.5 hacia la 4.5
mostrar(mapa);
t;

mapa[2][5]='X';//2.5
mostrar(mapa);
t;

mapa[3][5]='X';//3.5
mostrar(mapa);
t;

mapa[4][5]='X';//4.5 Hacia 4.7
mostrar(mapa);
t;

mapa[4][6]='X';//4.6
mostrar(mapa);
t;

mapa[4][7]='X';//4.7 hacia 7.7
mostrar(mapa);
t;

mapa[5][7]='X';//5.7
mostrar(mapa);
t;

mapa[6][7]='X';//6.7
mostrar(mapa);
t;

mapa[7][7]='X';//7.7 hacia 7.8
mostrar(mapa);
t;

mapa[7][8]='X';//7.8 hacia 8.8
mostrar(mapa);
t;

mapa[8][8]='X';//8.8 hacia 8.13
mostrar(mapa);
t;

mapa[8][9]='X';//8.9
mostrar(mapa);
t;

mapa[8][10]='X';//8.10
mostrar(mapa);
t;

mapa[8][11]='X';//8.11
mostrar(mapa);
t;

mapa[8][12]='X';//8.12
mostrar(mapa);
t;

mapa[8][13]='X';//8.13 hacia 10.13
mostrar(mapa);
t;

mapa[9][13]='X';//9.13
mostrar(mapa);
t;

mapa[10][13]='X';//10.13 hacia 10.5
mostrar(mapa);
t;

mapa[10][12]='X';//10.12
mostrar(mapa);
t;

mapa[10][11]='X';//10.11
mostrar(mapa);
t;

mapa[10][10]='X';//10.10
mostrar(mapa);
t;

mapa[10][9]='X';//10.9
mostrar(mapa);
t;

mapa[10][8]='X';//10.8
mostrar(mapa);
t;

mapa[10][7]='X';//10.7
mostrar(mapa);
t;

mapa[10][6]='X';//10.6
mostrar(mapa);
t;

mapa[10][5]='X';//10.5 hacia 13.5
mostrar(mapa);
t;

mapa[11][5]='X';//11.5
mostrar(mapa);
t;

mapa[12][5]='X';//12.5
mostrar(mapa);
t;

mapa[13][5]='X';//13.5 hacia 13.0
mostrar(mapa);
t;

mapa[13][4]='X';//13.4
mostrar(mapa);
t;

mapa[13][3]='X';//13.3
mostrar(mapa);
t;

mapa[13][2]='X';//13.2
mostrar(mapa);
t;

mapa[13][1]='X';//13.1
mostrar(mapa);
t;

mapa[13][0]='X';//13.0 hacia 16.0
mostrar(mapa);
t;

mapa[14][0]='X';//14.0
mostrar(mapa);
t;

mapa[15][0]='X';//15.0
mostrar(mapa);
t;

mapa[16][0]='X';//16.0 // hacia 16.15
mostrar(mapa);
t;

mapa[16][1]='X';//16.1
mostrar(mapa);
t;

mapa[16][2]='X';//16.2
mostrar(mapa);
t;

mapa[16][3]='X';//16.3
mostrar(mapa);
t;

mapa[16][4]='X';//16.4
mostrar(mapa);
t;

mapa[16][5]='X';//16.5
mostrar(mapa);
t;

mapa[16][6]='X';//16.6
mostrar(mapa);
t;

mapa[16][7]='X';//16.7
mostrar(mapa);
t;

mapa[16][8]='X';//16.8
mostrar(mapa);
t;

mapa[16][9]='X';//16.9
mostrar(mapa);
t;

mapa[16][10]='X';//16.10
mostrar(mapa);
t;

mapa[16][11]='X';//16.11
mostrar(mapa);
t;

mapa[16][12]='X';//16.12
mostrar(mapa);
t;

mapa[16][13]='X';//16.13
mostrar(mapa);
t;

mapa[16][14]='X';//16.14
mostrar(mapa);
t;

mapa[16][15]='X';//16.15 hacia 18.15
mostrar(mapa);
t;

mapa[17][15]='X';//17.15
mostrar(mapa);
t;

mapa[18][15]='X';//18.15 hacia 18.19
mostrar(mapa);
t;

mapa[18][16]='X';//18.16
mostrar(mapa);
t;

mapa[18][17]='X';//18.17
mostrar(mapa);
t;

mapa[18][18]='X';//18.18
mostrar(mapa);
t;

mapa[18][19]='X';//18.19 hacia 20.19
mostrar(mapa);
t;

mapa[19][19]='X';//19.19
mostrar(mapa);
t;

mapa[20][19]='X';//20.19 hacia 20.16
mostrar(mapa);
t;

mapa[20][18]='X';//20.18
mostrar(mapa);
t;

mapa[20][17]='X';//20.17
mostrar(mapa);
t;

mapa[20][16]='X';//20.16 hacia 21.16
mostrar(mapa);
t;

mapa[21][16]='X';//21.16 hacia 21.9
mostrar(mapa);
t;

mapa[21][15]='X';//21.15
mostrar(mapa);
t;

mapa[21][14]='X';//21.14
mostrar(mapa);
t;

mapa[21][13]='X';//21.13
mostrar(mapa);
t;

mapa[21][12]='X';//21.12
mostrar(mapa);
t;

mapa[21][11]='X';//21.11
mostrar(mapa);
t;

mapa[21][10]='X';//21.10
mostrar(mapa);
t;

mapa[21][9]='X';//21.9 hacia 24.9
mostrar(mapa);
t;

mapa[22][9]='X';//22.9
mostrar(mapa);
t;

mapa[23][9]='X';//23.9
mostrar(mapa);
t;

mapa[24][9]='X';//24.9 hacia 24.17*
mostrar(mapa);
t;

mapa[24][10]='X';//24.10
mostrar(mapa);
t;

mapa[24][11]='X';//24.11
mostrar(mapa);
t;

mapa[24][12]='X';//24.12
mostrar(mapa);
t;

mapa[24][13]='X';//24.13
mostrar(mapa);
t;

mapa[24][14]='X';//24.14
mostrar(mapa);
t;

mapa[24][15]='X';//24.15
mostrar(mapa);
t;

mapa[24][16]='X';//24.16
mostrar(mapa);
t;

mapa[24][17]='X';//24.17 hacia 23.17
mostrar(mapa);
t;

mapa[23][17]='X';//23.17 hacia 23.24
mostrar(mapa);
t;

mapa[23][18]='X';//23.18
mostrar(mapa);
t;

mapa[23][19]='X';//23.19
mostrar(mapa);
t;

mapa[23][20]='X';//23.20
mostrar(mapa);
t;

mapa[23][21]='X';//23.21
mostrar(mapa);
t;

mapa[23][22]='X';//23.22
mostrar(mapa);
t;

mapa[23][23]='X';//23.23
mostrar(mapa);
t;

mapa[23][24]='X';//23.24 Fin
mostrar(mapa);
t;

}


Método de fuerza bruta jaja 

No se si es eso pero me divierto jaja

Se puede quedar en la mitad si a cada "hacia" le pones un contador
y unos while y vas incrementando hasta llegar en el siguiente "hacia"
JAJAJ me lo paso bomba con esos programas tontos 

Código (cpp) [Seleccionar] Expandir


    #include <stdio.h>
    #include <conio.h>
    #include <dos.h>
    #include <windows.h>
    main()
    {
system("cls");
    int arreglo[25][25]={0},x=0,y=0;
    arreglo[1][0]=1;
    arreglo[1][1]=1;
    arreglo[1][2]=1;
    arreglo[1][3]=1;
    arreglo[1][4]=1;
    arreglo[1][5]=1;
    arreglo[2][5]=1;
    arreglo[3][5]=1;
    arreglo[6][7]=1;
    arreglo[5][7]=1;
    arreglo[4][5]=1;
    arreglo[4][6]=1;
    arreglo[4][7]=1;
    arreglo[7][8]=1;
    arreglo[7][7]=1;
    arreglo[8][8]=1;
    arreglo[8][9]=1;
    arreglo[8][10]=1;
    arreglo[8][11]=1;
    arreglo[8][12]=1;
    arreglo[8][13]=1;
    arreglo[9][13]=1;
    arreglo[10][13]=1;
    arreglo[10][12]=1;
    arreglo[10][11]=1;
    arreglo[10][10]=1;
    arreglo[10][9]=1;
    arreglo[10][8]=1;
    arreglo[10][7]=1;
    arreglo[10][6]=1;
    arreglo[10][5]=1;
    arreglo[11][5]=1;
    arreglo[12][5]=1;
    arreglo[13][0]=1;
    arreglo[13][1]=1;
    arreglo[13][2]=1;
    arreglo[13][3]=1;
    arreglo[13][4]=1;
    arreglo[13][5]=1;
    arreglo[14][0]=1;
    arreglo[15][0]=1;
    arreglo[16][0]=1;
    arreglo[16][1]=1;
    arreglo[16][2]=1;
    arreglo[16][3]=1;
    arreglo[16][4]=1;
    arreglo[16][5]=1;
    arreglo[16][6]=1;
    arreglo[16][7]=1;
    arreglo[16][8]=1;
    arreglo[16][9]=1;
    arreglo[16][10]=1;
    arreglo[16][11]=1;
    arreglo[16][12]=1;
    arreglo[16][13]=1;
    arreglo[16][14]=1;
    arreglo[16][15]=1;
    arreglo[17][15]=1;
    arreglo[18][15]=1;
    arreglo[18][16]=1;
    arreglo[18][17]=1;
    arreglo[18][18]=1;
    arreglo[18][19]=1;
    arreglo[19][19]=1;
    arreglo[20][19]=1;
    arreglo[20][18]=1;
    arreglo[20][17]=1;
    arreglo[20][16]=1;
    arreglo[21][16]=1;
    arreglo[21][15]=1;
    arreglo[21][14]=1;
    arreglo[21][13]=1;
    arreglo[21][12]=1;
    arreglo[21][11]=1;
    arreglo[21][10]=1;
    arreglo[21][9]=1;
    arreglo[22][9]=1;
    arreglo[23][9]=1;
    arreglo[24][9]=1;
    arreglo[24][10]=1;
    arreglo[24][11]=1;
    arreglo[24][12]=1;
    arreglo[24][13]=1;
    arreglo[24][14]=1;
    arreglo[24][15]=1;
    arreglo[24][16]=1;
    arreglo[24][17]=1;
    arreglo[23][17]=1;
    arreglo[23][18]=1;
    arreglo[23][19]=1;
    arreglo[23][20]=1;
    arreglo[23][21]=1;
    arreglo[23][22]=1;
    arreglo[23][23]=1;
    arreglo[23][24]=2;
   
    for(x=0;x<25;x++)
    {
    for(y=0;y<25;y++)
    {
    printf("%d",arreglo[x][y]);
    Sleep(50);
    }
    printf("\n");
    Sleep(50);
    }
   
   
system("pause");

}


Eso es lo que eh logrado pero lo unico que hace es imprimir numero a numero esperando un rato entre cada letra.
Me sale eso:
0000000000000000000000000
1111110000000000000000000
0000010000000000000000000
0000010000000000000000000
0000011100000000000000000
0000000100000000000000000
0000000100000000000000000
0000000110000000000000000
0000000011111100000000000
0000000000000100000000000
0000011111111100000000000
0000010000000000000000000
0000010000000000000000000
1111110000000000000000000
1000000000000000000000000
1000000000000000000000000
1111111111111111000000000
0000000000000001000000000
0000000000000001111100000
0000000000000000000100000
0000000000000000111100000
0000000001111111100000000
0000000001000000000000000
0000000001000000011111112
0000000001111111110000000
Presione una tecla para continuar . . .
pero va haciendo linea a linea.
numero a numero.
No se que es lo que quieres?

Que es eso:
for(y=0;y<25;y++)
{
I   //Eso me da error
}

existe unas cuantas formas de hacer el constructor.
Esta el constructor por defecto que si no le pasas parámetros el programa elige ese.
Pero si le pasa los parámetros a la hora de criar el objeto entonces el programa lo elige el otro.
Pero esta un 3º constructor que no viene al caso y no se si existe mas que se llama el constructor de copia.
Sirve para crear un objeto igual que el otro.
Imagines que todos viven en el mismo país y al crear un objeto no quieres introducir país para cada objeto, pues ahí es donde entra el constructor de copia.
Los 3 ejemplos en vídeos muy buenos sobre el tema los tiene aquí:
http://minidosis.org/C++/Clases/El%20Constructor%20por%20Defecto/
http://minidosis.org/C++/Clases/El%20Constructor/
http://minidosis.org/C++/Clases/El%20Constructor%20de%20Copia/
Aquí también el destructor:
http://minidosis.org/C++/Clases/El%20Destructor/

¡Mucha suerte! 

Código (cpp) [Seleccionar] Expandir



int MAXCOL = 10;
int MAXFIL = 10;


char mapa[MAXCOL][MAXFIL]={
"XXXXXXXXXX",
"X00P00000X",
"XXXXXXXX0X",
"X00000000X",
"XXX0XXXXXX",
"X0000X000X",
"X0XX000X0X",
"X0XX0XXX0X",
"X0000XXX0F",//<-Aqui la 'F' de final XD
"XXXXXXXXXX",
};

// Dado lo de arriba sabemos que 0 esta por descubrir  
// y lo que ya hemos caminado es 1, pero aun no caminamos nada.
// Las X nunca deben cambiar ;) o romperíamos una pared XDD
// La 'F' es de final si la queremos, en tu caso quieres recorrer el mapa completo pero
//ya veremos como XD
// Sabemos que el personaje aparece en un determinado punto del array mapa.
// Ese punto es mapa [1][3]¿no? Desde este punto deberemos realizar nuestro calculo de recorrido.
// Veamos como podemos hacer:
// Antes que nada hay que tener claro como se va mover el personaje.
// En mi caso se va mover de izquierda a derecha y al contrario de derecha a izquierda.
// Y también lo va hacer hacia arriba y hacia abajo.
// Eso en cálculos seria mas o menos así:
// Si se mueve a la derecha aumenta, si se mueve a la izquierda disminuye ¿ok?
// Entonces hacemos así:
// Usaremos coordenadas X y coordenadas Y, muy usadas para hacer un videojuego :D
// Como funciona?

// Declaramos 2 variables para representar la posición del tipo entero.
// Le damos el valor inicial del mapa de arriba para que inicie donde queremos
int y = 1; //
int x = 3; //

// Eso hace que el personaje inicie en la P del mapa de arriba.
mapa[y][x]

// ahora bien creo que lo vas captando ya la intención:D
// Si aumentamos la coordenada x
// La P pasaría de estar en la casilla 3 para estar en la 4 ¿no?Seria mas o menos así:

// MAXCOL 0 "XXXXXXXXXX",
// MAXCOL 1 "X00P00000X",
//           01234....9
//           |||||_MAXFIL 4->Aquí se va poner la P si le sumamos +1:D
//           ||||__MAXFIL 3->Aquí esta la P ahora
//           |||___MAXFIL 2
//           ||____MAXFIL 1
//           |_____MAXFIL 0

//Una vez incrementada la x así se queda
// MAXCOL 0 "XXXXXXXXXX",
// MAXCOL 1 "X000P0000X",
//           01234....9
//           |||||_MAXFIL 4->Aquí se va poner la P si le sumamos +1:D
//           ||||__MAXFIL 3->Aquí estaba la P Y nuestro personaje ya estuvo aquí, tenia que ser 1
//           |||___MAXFIL 2
//           ||____MAXFIL 1
//           |_____MAXFIL 0

// Una vez desplazado el personaje la posición anterior debería quedar en 1
// Antes personaje estaba en mapa[1][3]...ahora esta en mapa[1][4]
// Y la posición mapa[1][3] antigua ahora queda así mapa[1][3]=1
// Bueno mas o menos lo pillamos ¿no?

// Ahora que sabemos como nos movemos pues queda ver los casos que podemos movernos.
// Ejemplo: si nos movemos solo de arriba abajo y de un lado a otro pues
//si quiero ir a la izquierda antes tengo que ver si en esa izquierda esta la X (pared) o
//si ya hemos estado ahí antes, o sea 1.

// Algo así en código:

// Digamos que estamos en la posición mapa[1][4] con el incremento del ejemplo anterior
// Para saber si nos podemos ir a mapa[1][5](Derecha) una forma puede ser:

if ( mapa[1][5] == 0 )
  x++;
 
// si queremos ir hacia abajo

if ( mapa[2][4] == 0 )
  y++;
 
// El 1(campo ya explorado) en realidad el 1 no imposibilita atravesar-lo.
// Imagine que llegues a un punto como este y salimos de la V:
//     XXXXXXXXXXXX
//     XV11111111PX
//     XXXXXX0XXXXX
//     X000000XXXXX

// Como ves la única forma de salir es volver hacia donde ya hemos pasado hasta llegar aquí:
//     XXXXXXXXXXXX
//     X11111P1111X
//     XXXXXX0XXXXX
//     X000000XXXXX

// Pues aquí el personaje puede ir hacia 3 direcciones, pero solo una es la buena
// Debes de hacer que prefiera la 0 envés de 1, pero si no hay remedio pues que pase
// por 1 hasta llegar a otro 0 :D

// Bien solo nos queda lo del final 'F'
// si lo que quieres es que encuentre el F antes de terminar bien caso contrario puedes
//poner una validación de si no encontrado todos los 0 no puedes salir
// O simplemente si todo los ceros se terminaron pues FIN XD
// Eso es un poco de lógica de videojuegos.
// No se si te sirve pero es algo :D


Espero que te sirva.
Me ha dado una gana de hacer un come cocos jaja
¡Mucha suerte!

Cambia a la SDL2.0, pero eso si esta echa en c. Trae muchas cosillas nuevas
Y es mas nueva que SFML 

Una función entonces

void obtenervalor( &variable  ){
   //aquí su código
}

Si se encuentra en el mismo directorio si, caso contrario debes poner la ruta c:...
Otra cosa que veo en tu código es que no me compilo pero no veo nada malo en el.

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main(){

FILE *f = fopen("fichero.txt", "r");

if (f==NULL){
  perror ("Error al abrir fichero.txt");
   }
return 0;
}  

Este es lo mismo casi y si me anda


Y este es el mas cercano a ltuyo:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main(){

FILE *fd;
if ( (fd = fopen("fichero.txt", "r"))==NULL){
    perror ("Error al abrir fichero.txt");
    }
    else
    printf("TODO OK");
return 0;
}   

Suerte!

:3
Te sirve?

Código (c) [Seleccionar] Expandir


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

int main()
{
    int peticion;
    int cuadrado = 1;

    printf("Ingrese la figura que quiera representar\n Elija entre: 1=Cuadrado, 2=Triangulo y un 3=Rectangulo\n\n");
    scanf("%d", &peticion);

    if (peticion == cuadrado)
        printf("******\n*    *\n*    *\n*    *\n*    *\n*    *\n*    *\n******");


    return 0;
}


haces otros ifs para los demas casos y tooodo resuelto XDD

por su puesto, los libros de Anaya son muy buenos, y para avanzados, los de Deitel son los mejores, finalmente, los de Ritchie/Kernnigan --The C Programming Language--  y Eckel --Como Pensar en C++ -- son duda los ejes centrales para aprender, ni siquiera dominar, lo que se necesita para saber C/C++.

Ahora, a modo personal, recomiendo este, es excelente:



Tiene justo lo que se necesita, va al punto, ejemplos claros, precisos, excelentemente explicados, y la cantidad de ejercicios, son abundantes y muy interesantes, y mezcla de una manera muy buena el proceso de aprendizaje, sin una curva de dificultad muy prolongada, claro esta, depende del empeño que uno le ponga, yo en este libro estoy haciendo ejercicios del capitulo de Clases y Objetos, de la sección de C++. Este libro enseña muy bien lo que se necesita, en un orden bastante apropiado:

C ---> UML ---> C++ ---> Java

Por que en ese orden??? sencillo, porque inicia enseñando las bases de cualquier lenguaje de programación, manejando la programación estructurada, y evoluciona hacia el modelamiento y el BPM (Bussiness Project Manager) con UML (Unified Modeling Language) y sigue avanzando hacia la POO (Programación Orientada a Objetos).

Recomiendo totalmente este libro, vale la pena la inversión.

Alguien tiene este libro en pdf o sabe donde se puede encontrar?