How can I make a portable executable?

It's there a way to compile a c/c++ source file to output a .exe file that can be run on other processors on different computers ? I am asking this for windows platform开发者_如何转开发. I know it can be done with java or c# , but it uses virtual machine.

PS: For those who said that it can be done just with virtual machines or the source cod must be compiled on every machine , i am asking if all viruses are written in java or c# and you need a vm machine to be infected or you need to compile source cod of worm on your machine to be infected ? (i am not trying to make a virus, but is a good example :) )

Different computers use different instruction sets, OS system calls, etc., which is why machine code is platform specific. This is why various technologies like byte code, virtual machines, etc., have been developed to allow portable executables. However, generally C/C++ compiles directly to platform-specific machine code.

So a Windows exe simply won't run on another platform without some kind of emulation layer.

However, you can make your C/C++ source code portable. This means all you need to do to make your application run on another platform is to compile it for that platform.

Yes, you can, but it's not necessarily a good idea.

Apple introduced the idea of a fat binary when they were migrating from the Motorola 68000 to the PowerPC chips back in the early 90s (I'm not saying they invented it, that's just the earliest incarnation I know of). That link also describes the FatELF Linux universal binaries but, given how little we hear about them, they don't seem to have taken off.

This was a single file which basically contained both the 68000 and PowerPc executables bundled into one single file and required some smarts from the operating system so it could load and execute the relevant one.

You could, if you were so inclined, write a compiler which produced a fat binary that would run on a great many platforms but:

• it would be hideously large; and
• it would almost certainly require special loaders on each target system.

Since gcc has such a huge amount of support for different platforms and cross-compiling, it would be where I would concentrate the effort, were I mad enough to try :-)

The short answer is - you can't. Longer answer is write in portable (standard) C/C++ and compile on the platforms you need.

You can, however, do it in a different language. If you need something to run on multiple platforms, I suggest you investigate Java. Similar language to c/c++, and you can "compile" (sort of) programs to run on pretty much any computer.

Do not confuse processor platforms with OS platforms. for different OS platforms, machine binaries are altogether different. even not possible to make one-to-one instruction mapper. it is beacause whole instruction set architecture may be different, and different instruction groups may have totally different instruction format, and even some instructions may be missing or target platform. Only an emulator or virtual machine can do this.

Actually, some operating systems support this; it is usually called a "fat binary".

In particular, Mac OS uses (used) it to support PowerPC and x86 in one binary.

On MS Windows however, this is not possible as the OS does not support it.

Windows can run 32bit executables in 64bit mode with no problem. So your exe will be portable if you compile it in 32bit mode. Or else you must release 2 versions of your executable. If you use Java or C# (or any bytecode-compiled language), the JIT/interpreter can optimize your code for the current OS's mode, so it's fully portable. But on C++, since it produces native code, I'm afraid this can't be done except using 2 versions of your binary.

The trick to do this, is to create a binary which has machine instructions which will be emulated in a virtual machine on the operating systems and processors you want to support.

The most widely spread such virtual machine are variants of the Java virtual machine. So my suggestion would be to look at a compiler which compiles C code to Java byte code.

Also, Windows once upon a time treated x86 as a virtual machine on other (Alpha) architectures.

To summarize the other answers, if you want to create a single executable file that can be loaded and run on multiple platforms, you basically have two options:

1. Create a "fat binary", which contains the machine code for multiple platforms. This is not normally supported by most development tools and may require special loaders on the target platform;

2. Compile to a byte code for the JVM or for .Net. I've heard of one C compiler that generates Java byte code (can't remember the name offhand), but never used it, nor do I have any idea what the quality of the implementation would be.

Normally, the procedure for supporting multiple platforms in C is to generate different executables for each target, either by using a cross compiler or running a compiler on each platform. That requires you to put some thought into how you write and organize your source code so that the platform-specific bits can be easily swapped out without affecting the overall program logic, for varying degrees of "easily".

The short answer is you can't, The long answer is there are several options.

1. Fat Binary. Downside is that this requires OS support. The only user level OS I know of that supports it is OS X for their power pc to Intel migration.
2. On the fly cross translation. As used by Transmeta and Apple. Again no general solution provider that I know of.
3. a C\C++ interpreter. There is at least one I am aware of Ch. It runs on Windows, Linux, OS X. Note Ch is not fully C++ compatible.

This question likes to that ask "Is there a way can travel from Canada to another city in the world?"

And answer is: "yes there is."

for compiling a C/C++ Source code to an Executable file on Windows Platform without any virtual machine you can use Windows Legacy API or MFC (specially with use MFC in a Static Library instead in Dll). This executable file approximately runs on all PCs that have windows, because windows runs on only 3 platforms (x86, x64, IA64; except windows 8 & 8.1 that supports ARMs).Of course you should compile your source to x86 codes to run on 32 bit and x86-64 platforms and Itaniums can run your exe in emulation. But about all Processors that runs windows as their OS (Like ARMS in mobiles) you should compile that for the Windows Phone or Windows CE.

You can write a mid-library~ such as:

      [ Library ]

     [ mid-library]

[linux part] [windows part]

then, you can use library, your app will be portable~~