Foro de elhacker.net

Tengo un código y lo estoy compilando con varios ide para ver diferencias entre el ejecutable que crean, codeblocks a parte del ejecutable crea un archivo.o y ni idea de para que sirve, por lo que parece el ejecutable no depende el.
Un saludo.

Es un archivo binario

Es un archivo objeto.

Ah vale! :)

¿No es lo mismo?

El binario es el "ejecutable" y el archivo objeto en un archivo que contiene el código que se utiliza para unirlo con otro archivo objeto con el linker y hacer un solo programa no? Se usa para proyectos grandes creo. 

Según lei yo, el archivo .o contiene el bytecode.

Ahora si que ya no me entero, entonces lo puedo eliminar? O hace que el ejecutable sea más rápido o algo?

La compilación se divide en varias partes: dos de ellas son la compilación (código objeto) y el enlazado (código máquina).

http://es.wikipedia.org/wiki/Compilador#Proceso_de_compilaci.C3.B3n

Para que resuelvas las dudas que te queden.

---

Una vez enlazado, es decir, una vez tienes un .exe, puedes borrarlo, ya no es necesario.

Sa1uDoS

Lo puedes eliminar y no lo debes eliminar.

Tu imagínate que tienes un gran proyecto que tardase en compilar 20 minutos. Si cada vez que tienes que cambiar una línea de código te tiras 20 minutos no llegas a ninguna parte.

Lo que se hace, es dividir el proyecto en varios archivos cpp. Cada archivo cpp se compila de forma autonóma, después se unén los archivos compilados (linker) y se forma el programa.

De este modo que si cambias una línea de código solo tendrías que compilar ese fichero cpp. Los archivos cpp compilados suelen tener extensión .o. No hay peligro en eliminarlos pero después tendrías que volver a compilarlos desde 0.

¿Cómo se hace un proyecto con varios archivos? En Codeblocks está chupado (File -> New Emply file y lo guardas con extensión .cpp). He aquí un ejemplo con 3 archivos (uno de cabecera hpp):

Main.cpp

#include <iostream>
#include <map>
#include <vector>
#include <sstream>
 
// Archivo de declaraciones
 
#include "Funciones.hpp" 
 
using namespace std;
 
typedef void (*Puntero_A_Funcion)(void);
 
int main()
{
    void (*Funcion)(void); // Puntero a funcion sin argumentos
    string Mensaje;
    map<string,Puntero_A_Funcion> Comandos;
    vector<string> texto;
    string str;
 
    Comandos["write"] = Escribir;
    Comandos["copy"] = Copiar;
    Comandos["cut"] = Cortar;
    Comandos["delete"] = Borrar;
    Comandos["Destroy"] = Destruir;
    Comandos["Kill"] = Matar;
 
    getline(cin, str);
    stringstream is(str);
 
    while(is >> str) texto.push_back(str);
 
    cout <<"Las palabras que pusiste son: " << endl;
 
    for (int i = 0; i < texto.size(); i++)
        cout << i + 1 << ". " << texto[i] << endl;
 
    cout << endl;
 
    for (int i = 0; i < texto.size(); i++)
    {
        Funcion = Comandos[texto[i]]; // Obtengo el puntero a la funcion correspondiente
 
        if (Funcion) // Si existe la funcion
              Funcion(); // llamar a la funcion
        else
             cout<<"Error, no existe el comando introducido: "<<texto[i]<<endl;
    }
 
    return 0;
}

Funciones.hpp

// Se le dice al compilador que este archivo es de "inclusión única"
 
#pragma once 
 
// Prototipos de las funciones
 
void Copiar();
void Escribir();
void Cortar();
void Borrar();
void Destruir();
void Matar();
 

Funciones.cpp

// Incluimos el archivo con los prototipos
 
#include "Funciones.hpp" 
 
// Definiendo las funciones
 
void Escribir()
{
    cout<<"Has escrito write"<<endl;
}
 
void Cortar()
{
    cout<<"Has escrito cortar"<<endl;
}
 
void Copiar()
{
    cout<<"Has escrito copiar"<<endl;
}
 
void Borrar()
{
    cout<<"Has escrito borrar"<<endl;
}
 
void Destruir()
{
    cout<<"has escrito destruir"<<endl;
}
 
void Matar()
{
    cout<<"has escrito matar"<<endl;
}
 

Vamos, que si es un programa simple y es un solo archivo puedes borrarlo, pero si es un proyecto grande es mejor guardarlos para ahorrar tiempo a la hora de volver a compilarlo.

Muy buena explicación, ya me quedó claro de todo! Gracias a los todos. :)