The following code snippet is used to test output binary performance. The purpose of the code is for performance test, its accuracy is not verified.

// fastinit.cpp : Defines the entry point for the console application.
// g++ -I/cygdrive/d/opensource/boost/boost_1_35_0 -O3 fastinit.cpp -o f.exe
#include <iostream>
#include <string>
#include <windows.h>
#include <boost/scoped_array.hpp>
class ProfileTimer
{
public:
    ProfileTimer(const std::string& name)
    {
        m_description = name;
        QueryPerformanceCounter( &m_start_time);
        m_start_tick = GetTickCount();
    }
    ~ProfileTimer()
    {
        DWORD used_tick = GetTickCount()-m_start_tick;
        LARGE_INTEGER  current_time;
        QueryPerformanceCounter( &current_time);
        LARGE_INTEGER  frequency;
        QueryPerformanceFrequency(&frequency);
        double seconds = (current_time.QuadPart-m_start_time.QuadPart)*1000.0/frequency.QuadPart;
        std::cout << m_description << " use " << seconds << " milliseconds, "
            << used_tick << " tick count."<< std::endl;
    }
    LARGE_INTEGER  m_start_time;
    DWORD m_start_tick;
    std::string m_description;

};
template<typename T>
void fastinit(T* array_op, std::size_t count, const T& init_value)
{
    if (sizeof(T)==1)
    {
        memset(array_op, *((int*)&init_value), count);
        return;
    }
    if (count<1)
        return;
    array_op[0] = init_value;
    int initialed_count = 1;
    int copy_bytes = sizeof(T);
    int max_bytes = sizeof(T)*count;
    while(copy_bytes < max_bytes)
    {
        int copy_count = min(max_bytes-copy_bytes, copy_bytes);
        memcpy(array_op+initialed_count, array_op, copy_count);
        copy_bytes+=copy_bytes;
    }
}

template<typename T>
void forinit(T* array_op, std::size_t count, const T& init_value)
{
    for(std::size_t i=0;i<count;i++)
        array_op[i] = init_value;
}

struct s1
{
    int a;
    long b;
    float c;
    double d;
    short e;
    char f;
};

int main(int argc, char* argv[])
{

    int times = 20000;
    if (argc>1)
        times = atoi(argv[1]);
    while (times<20000)
        times += times;
    const int element_count = 10240;
    std::cout << std::endl;

#if defined _MSC_VER && !defined (__INTEL_COMPILER)
    std::cout << " VC++ " << _MSC_VER;
#endif

#ifdef __GNUC__
    std::cout << " GCC " << __GNUC__;
#endif

#ifdef __INTEL_COMPILER
    std::cout << " Intel C++ " << __INTEL_COMPILER
        << " VC++ compability level: " << __INTEL_MS_COMPAT_LEVEL;
#endif

    std::cout << " element count:" <<element_count
        <<", loop " << times << " times." << std::endl;
    int data[element_count];
    {

        ProfileTimer a("initial int arrray with fast method");
        {
            for(int i=0;i<times; i++)
                fastinit(data, element_count, 0x12345678);
        }
    }

    {
        ProfileTimer  b( "initial int arrray with for method");
        {
            for(int i=0;i<times; i++)
                forinit(data, element_count, 0x12345678);
        }
    }
    boost::scoped_array<s1> s_array(new s1[element_count]);
    s1 s_one = {1,2,3,4,5,6};
    {

        ProfileTimer a("initial struct arrray with fast method");
        {
            for(int i=0;i<times; i++)
                fastinit(s_array.get(), element_count, s_one);
        }
    }

    {
        ProfileTimer  b( "initial struct arrray with for method");
        {
            for(int i=0;i<times; i++)
                forinit(s_array.get(), element_count, s_one);
        }
    }

    return 0;
}

VC++ 2008 Optimize level: /O2

G++ Optimize level: -O3

Result:

GCC 3 element count:10240, loop 80000 times.
initial int arrray with fast method use 4629.66 milliseconds, 4640 tick count.
initial int arrray with for method use 822.303 milliseconds, 813 tick count.
initial struct arrray with fast method use 7409.42 milliseconds, 7422 tick count.
initial struct arrray with for method use 4208.53 milliseconds, 4203 tick count.

Intel C++ 1010 VC++ compability level: 1 element count:10240, loop 80000 times.
initial int arrray with fast method use 582.76 milliseconds, 578 tick count.
initial int arrray with for method use 590.338 milliseconds, 594 tick count.
initial struct arrray with fast method use 3487.38 milliseconds, 3484 tick count.
initial struct arrray with for method use 4362.1 milliseconds, 4375 tick count.

VC++ 1500 element count:10240, loop 80000 times.

initial int arrray with fast method use 959.708 milliseconds, 969 tick count.
initial int arrray with for method use 0.000596903 milliseconds, 0 tick count.
initial struct arrray with fast method use 6287.94 milliseconds, 6281 tick count.
initial struct arrray with for method use 8070.71 milliseconds, 8079 tick count.

But, the following code can't tell difference between compilers:

// compilertest.cpp : Defines the entry point for the console application.
//  g++ compilertest.cpp -O3 -o b.exe
#ifdef _MSC_VER
#include "stdafx.h"
#endif
#include <windows.h>
#include <iostream>
int test1(int a, int b)
{
    int ret = a*a + b*b + a*b;
    ret = ret+__LINE__;
    ret = ret * (ret+1) * (ret+2)*(ret+3);
    return ret;
}
int main(int argc, char* argv[])
{
    DWORD start_tick = GetTickCount();
    int run_count = 1000000;
    if (argc>1)
        run_count = atoi(argv[1]);
    while (run_count < 1000000)
        run_count += run_count;
    int ret = 0;
    for (int i=0;i<run_count; i++)
    {
        ret = test1(__LINE__, ret);
    }
    DWORD used_tick = GetTickCount() - start_tick;

#ifdef _MSC_VER
    std::cout << "VC++ " << _MSC_VER;
#endif

#ifdef __GNUC__
    std::cout << " GCC " << __GNUC__;
#endif

    std::cout << " Run " << run_count << " loops return " << ret
        <<" takes " << used_tick << " ms." << std::endl;
    return 0;
}

nafxcw.lib(afxmem.obj) : warning LNK4006: "void * __cdecl operator new(unsigned int)" (??2@YAPAXI@Z) already defined in LIBCMT.lib(new.obj); second definition ignored
nafxcw.lib(afxmem.obj) : warning LNK4006: "void __cdecl operator delete(void *)" (??3@YAXPAX@Z) already defined in LIBCMT.lib(delete.obj); second definition ignored
nafxcw.lib(afxmem.obj) : warning LNK4006: "void * __cdecl operator new[](unsigned int)" (??_U@YAPAXI@Z) already defined in libcpmt.lib(newaop.obj); second definition ignored
nafxcw.lib(afxmem.obj) : warning LNK4006: "void __cdecl operator delete[](void *)" (??_V@YAXPAX@Z) already defined in LIBCMT.lib(delete2.obj); second definition ignored
Release\ipc_all_client.exe : warning LNK4088: image being generated due to /FORCE option; image may not run
Embedding manifest...
mt.exe : general error c101008a: Failed to save the updated manifest to the file ".\Release\ipc_all_client.exe.embed.manifest". The parameter is incorrect.

The first error comes as early as VC++ 6.0, which I think should be fixed in VC++ as a special case, otherwise I have to add "nafxcw.lib libcmt.lib" to "Additional Dependencies" and "Ignore Specific Library" explicitly.

The second error is intermittent and can be fixed by "rebuild".

Just after upgraded to Visual Assist X 10.4.1638.0, my VC++ 2008 keeps crashing at startup. Restoring Visual Assist X 10.4.1626.0 fixed this problem.

C:\Program Files\Microsoft Visual Studio 9.0\VC>cd \
C:\>set PYTHON_ROOT=c:\python25
C:\>set PYTHON_VERSION=2.5
C:\>set ICU_PATH=D:\src\ICU\icu4c-3_8_1\icu
C:\>d:
D:\>cd src\boost\boost_1_35_0
D:\src\boost\boost_1_35_0>bjam -sHAVE_ICU=1 --toolset=msvc stage --build-type=complete

D:\src\boost\boost_1_35_0>bjam -sHAVE_ICU=1 --toolset=msvc --with-python --build-type=complete stage

Note: boost.python does not work with python 3.0.

build boost.mpi

Install MPICH2 1.0.7 Windows Binary from here;

update include and lib environment variables;

add some lines to boost\tools\build\v2\user-config.jam:

using mpi : : <find-shared-library>cxx
              <find-shared-library>mpi
              <library-path>C:/ENV/MPICH2/lib ;

run build command: D:\src\boost\boost_1_35_0>bjam --toolset=msvc --with-mpi --build-type=complete stage

another build command style: D:\opensource\boost\boost_1_35_0>bjam --toolset=msvc -sPYTHON_ROOT=c:\python25 -sPYTHON_VERSION=2.5 --build-type=complete stage

Setup Eclipse as IDE for Microsoft Visual C++ Toolkit 2003

Tutorial: An Example Tool Chain

Extending the Eclipse CDT Managed Build System

Eclipse plug-in for Symbian C++ development

-Wl,--subsystem,windows passes `--subsystem windows' to the linker.  

-mwindows is a compiler option.

"it seems that if you use -mwindows you shouldn't need to also use
-Wl,--subsystem,windows, since that will happen anyhow..."

from Ian

Once I was asked a question: how to avoid duplicating virtual method declaration in both base class and derived classes? Because there are more than 100 pure virtual functions he has to copy to every derived class. My first answer is using MACRO to expand method declaration, but it is not very realistic and it may hit limitation of compiler -- the line would become too long. Today I suddenly remembered the fact that #include statement just copy files into the compilation unit, so some stuff can be put into a header file and be included inside class declaration, like the following example.

// begin of sharedbase.h
// This header file can't be used as standalone, it is meaned to be
// embedded in class declaration.

#ifndef PURE_VIRTUAL_PLACE_HOLDER
#define PURE_VIRTUAL_PLACE_HOLDER
#define REMOVE_VIRTUAL_PALCE_HOLDER
#endif

virtual void method1()    PURE_VIRTUAL_PLACE_HOLDER;
virtual void method2() PURE_VIRTUAL_PLACE_HOLDER;

#ifdef REMOVE_VIRTUAL_PALCE_HOLDER
#undef REMOVE_VIRTUAL_PALCE_HOLDER
#undef PURE_VIRTUAL_PLACE_HOLDER
#endif
// end of sharedbase.h

// begin of base.h
class Base2
{
public:
#undef PURE_VIRTUAL_PLACE_HOLDER
#define PURE_VIRTUAL_PLACE_HOLDER =0
#include "sharedbase.h"
#undef PURE_VIRTUAL_PLACE_HOLDER
};

class Derived2A : public Base2
{
public:
#include "sharedbase.h"
};

class Derived2B : public Base2
{
public:
#include "sharedbase.h"
};

// end of base.h

#include "base.h"
#include <iostream>

void Derived2A::method1()
{
    std::cout << __FUNCTION__ << std::endl;
}

void Derived2A::method2()
{
    std::cout << __FUNCTION__ << std::endl;
}

void Derived2B::method1()
{
    std::cout << __FUNCTION__ << std::endl;
}

void Derived2B::method2()
{
    std::cout << __FUNCTION__ << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
    Derived2A obj2a;

    return 0;
}

There is a #import directive in stdafx.h beneath declaration of a class which is derived from CComModule. VC6 always reports internal compiler error on source files that includes this stdafx.h, but VC++ 2005 is OK. The trick for VC6 is to move #import directive above declaration of the class.