Mensajes

Es cierto que en modo release el ejecutable.exe es más pequeño, ¿pero funciona por igual no? porque eso de que tengan distinto tamaño y hagan lo mismo me confunde.

El modo DEBUG tiene simbolos de depuración en el código, eso sirve para detectar las variables/instrucciones en el depurador.

Si no vas a depurar el progama no tiene sentido que pongas los simbolos ^^

He estado haciendo unas pruebas y te doy la razón, entonces cuando compilamos un proyecto, el ejecutable.exe compilado ya está listo para exportar, es decir creo un programa lo compilo, te paso su ejecutable.exe y tu ya puedes trabajar con él, sin necesidad de nada más.

En efecto.

Aunque algunas personas (no todas) pueden tener problemas de que les falta una DLL. Por eso te recomiendo que te vayas a Settings -> Compiler -> Linker Settings y en la columna de la derecha pongas "-static" (sin comillas claro).

El ejecutable.exe no actúa con independencia, necesita el main.o que es el código binario del programa, y el ejecutable.exe lo que se encarga es de lanzarlo, lo que busco es alguna manera de fusionar estos archivos o algo para que el ejecutable.exe sea capaz de ejecutar el programa con independencia.

Lo primero es, que si no vas a usar el depurador lo compiles en modo "Release". Más que nada porque los exe son más ligeros.

Segundo, lo que dices no es cierto, no hace falta el main.o para lanzar el archivo... ¿De donde sacas eso?

El compilador crea un exe que se ejecuta independiente, al menos en windows sí 

Si acaso, puedes pasarlo el modificador -static al compilador (en el caso que hubiera problema con las DLL).

El primer parametro es el inicio, el segundo el final y el tercero es un puntero a la función que vas a usar para hacer las comparaciones.

Lo que pasa esque declarar una función aparte para luego no usarla nunca más... Las funciones lambda permiten declarar esas funciones "inline", ahorrandote escritura y espacio.

No es stream.h, es <iostream>

Además te falta el "using namespace std;"

Pasate por aquí:
http://foro.elhacker.net/programacion_cc/usaco_problemas_de_progamacion_para_practicar-t406686.0.html

Aunque quizas te guste hacer un proyecto por tú cuenta.

Doy por hecho que usas C++.

Función que lista directorios en Windows:

Código (cpp) [Seleccionar] Expandir

void listarDirectorio(std::string Cosa)
{
   // Variables del sistema

   WIN32_FIND_DATA findFileData;
   HANDLE          hFind;

  // Variable auxiliar

   std::string Buffer;

   // Iniciamos la busqueda y le pasamos un valor a nuestro Handle

   hFind = FindFirstFile(Cosa.c_str(), &findFileData);

   // Si no existe la carpeta

   if (hFind == INVALID_HANDLE_VALUE)
   {
       std::cout << "La carpeta no existe o no se puede acceder";
   }

   else
   {
       // Si existe, pasamos al siguiente fichero (el primero solo contiene basura)

       FindNextFile(hFind, &findFileData);

       // Listamos todos los ficheros restantes

       while (FindNextFile(hFind, &findFileData) != 0)
       {
           Buffer = Cosa; // Creamos una variable de nombre con el valor del directorio
           Buffer.erase(Buffer.size()-1); // Borramos el asterisco
           Buffer += findFileData.cFileName;

           if (GetFileAttributes(Buffer.c_str()) == FILE_ATTRIBUTE_DIRECTORY)
           {
               Buffer += "\\*";
               listarDirectorio(Buffer);
           }
           else
           {
               std::cout<<Buffer<<endl;
           }
       }
   }
}

Es importante que le pases a la función la ruta "*" para que te marque la carpeta actual.

[unsigned int]

El problema es que pusiste unsigned int.

¿Qué número POSITIVO no es mayor o igual a 0?
O pones i<longitud+1 o pones int en vez de unsigned int.

Un consejo NOB2014, no uses variables unsigned si tienes que hacer condiciones. Puede provocar errores extraños si te despistas.

Por cierto amchacom. 16 colores es lo mismo que 16 bits o como va eso?  

PD:Ya lo encontré en un post tuyo creo al cual le destripas un BMP
4bits=16 colores.

Es bastante baja resolución ¿no?

No es baja resolución (eso sería una imagen pequeñita) simplemente tiene pocos colores.

Para una foto no te vale, pero para un dibujo tonto te puede valer y era una forma de ahorrar espacio.

PD: ¿Era este link el que mirastes?
http://www.elotrolado.net/hilo_imagenes-bmp-destripandolas-a-fondo_1807836

En las últimas respuestas, un usuario posteó un enlace a una clase BMP hecha en C++. Es interesante de ver

tengo entendido que solo se pueden abrir imagenes con extension .bmp

El lenguaje no te limita a nada, tú puedes abrir cualquier archivo que se te ocurra siempre que sepas como funciona. Lo que pasa esque el BMP tiene un funcionamiento "relativamente" sencillo.

Te pongo comentarios en el código, pero sin saber como funciona un BMP te vas a liar:

Código (cpp) [Seleccionar] Expandir


int muestraBMP(int x, int y, char* NomArchivo)
{
    int b,a;
    BMP Obj; // una estructura que contiene todos los datos de la cabecera

    unsigned char* Datas;
    int in=0;
    unsigned char c=0;
    FILE * fp;

    fp = fopen(NomArchivo,"rb"); // abrimos el archvio en cuestion

    // si no se encuentra, mostramos un mensaje de error y abortamos el progama

    if(!fp){   
    printf("Error : No se puede abrir el archivo ...");
getch();
    exit(0);
    }

    // leemos la "cabecera" del BMP

    fread(&Obj, sizeof(Obj), 1, fp);
   
    /* Este código está preparado para leer imagenes en 16 colores. Cualquier imagen que quieras
    usar de prueba debe guardarse en esos colores.
   
    El if siguiente comprueba esto y muestra un mensaje de error en el caso contrario */

    if(Obj.BitsPerPixel!=4)  /* Este NO es un bmp de 16 colores que podamos leer*/
    {
     fclose(fp);
     printf("Error : Formato de archivo no soportado...");
getch();
     exit(0);
    };

    /* Unos de los parametros de la firma BMP indica la posición del archivo donde comienzan los datos de imagen, se coge ese parametro y se avanza a esa posición */

    fseek(fp,Obj.OffSet,SEEK_SET);

    // Se reservan los suficientes datos para una fila de la imagen

    Datas=(unsigned char*) calloc(Obj.Width/2+1, sizeof(unsigned char));

   // Guardamos los datos de la imagen

    for(b=Obj.Height;b>=0;b--)
    {
     fread(Datas, sizeof(unsigned char), Obj.Width/2, fp); // Leemos una fila de la imagen
     c=0;
     in=0;
     for(a=0;a<=Obj.Width;a+=2)
     {
c = (Datas[in] | 0xF0) & 0x0F; //cogemos el dato relativo al primer pixel
         putpixel(a+1+x,b+y,c); // pintamos un pixel
         c = (Datas[in] | 0x00) >>4; // cogemos el dato relativo al segundo pixel
         putpixel(a+x,b+y,c); // pintamos el otro pixel (cada byte = 2 pixeles).
         in++;
     }
    }

    // liberamos memoria, cerramos el archivo y devolvemos un 1 para indicar que todo fue correcto

    free (Datas);
    fclose(fp);
    return 1;
}

Decirte además que Turbo C está muerto desde hace 10 años y que no deberías focalizar tu aprendizaje en esas cosas.