What is inline? This keyword is mainly used to ask the compiler to inline substitution of the function body at the point of call. Like 'register', this is only a suggestion to the compiler. Modern compiler can handle inlining using advanced heuristic to get better size / performance balance without the suggestion from the developer. So most of the time, it is unnecessary to use this keyword.

Then what else? Here is the whole story of inline.

Besides the suggestion to the compiler, inline keyword will also have some side effects.

Assuming I have defined a function 'f' in header file and include the header in two different files: a.cpp and b.cpp. Like:

void f() {}

You'll get the following error when compiling (cl a.cpp b.cpp):

b.obj : error LNK2005: "void __cdecl f(void)" (?f@@YAXXZ) already defined in a.obj
a.exe : fatal error LNK1169: one or more multiply defined symbols found

However, if you change the definition of f to:

inline void f() {}

The compilation will succeed.

Here are the words from the standard:

Every program shall contain exactly one definition of every non-inline function or object that is used in that program. An inline function shall be defined in every translation unit in which it is used.

This is the fundamental difference between using or not using inline. That means inline functions can be defined multiple times in different translation unit (assuming they have exactly the same definition in every case), but it will also cause the so-called "inline-explosion" because the definition has to be duplicated.

A function defined within a class definition is an inline function. If you don't want to duplicate the definition everywhere, it is better to move the definition into a separate cpp. /LTCG can still inline it if appropriate. 

According to C standard, it only supports output text in MBCS (Multi-Byte Character String):

n1124.pdf, 7.19.3/12

The wide character output functions convert wide characters to multibyte characters and write them to the stream as if they were written by successive calls to the fputwc function. Each conversion occurs as if by a call to the wcrtomb function, with the conversion state described by the stream’s own mbstate_t object. The byte output functions write characters to the stream as if by successive calls to the fputc function.

However, MBCS doesn’t support mixing characters in different code page. For example, you can’t use both Chinese and Japanese.

VC provides extension to allow you to output text in Unicode:

#include <cstdio>
#include <locale.h>

#include <io.h>
#include <fcntl.h>

void OutputMBCS(FILE *f)
{
    // ".936" is the code page for Simplified Chinese
    // However, you can't use ".1200" (code page for Unicode) to output text in Unicode
    setlocale(LC_CTYPE, ".936");
    // My name in Chinese: "范翔"
    fwprintf(f, L"%s", L"\x8303\x7FD4");

    // The text in the file is encoded in GBK
}

void OutputUnicode(FILE *f)
{
    _setmode(_fileno(f), _O_U16TEXT);
    fwprintf(f, L"%s", L"\x8303\x7FD4");

    // The text in the file is encoded in Unicode
}

For more information, please check the following post: http://blogs.msdn.com/michkap/archive/2008/03/18/8306597.aspx

This is an intellectual exercise: when shifts a 32-bit unsigned integer in C++, how to detect whether the calculation overflows efficiently?

Here is the function prototype. shl_overflow will return true if v << cl overflows (cl is between 0 and 31. And we assume that sizeof(unsigned long) == 4 and sizeof(unsigned long long) == 8).

bool shl_overflow(unsigned long v, int cl)

The most natural way to implement this function is to extend v to 64-bit integer:

bool shl_overflow(unsigned long v, int cl)
{
    unsigned long long vl = v;
    return (vl << cl >> 32) != 0;
}

Now, let’s dig into the assembly world. We’ll limit the discussion on x86.

mov     eax, DWORD PTR _v$[esp-4]
mov     ecx, DWORD PTR _cl$[esp-4]
xor     edx, edx
call    __allshl
xor     eax, eax
or      eax, edx
jne     overflow

The implementation has to use three specific registers: eax, edx and ecx. And there is an expensive external function call.

If you step into __allshl in the debugger, you can find that it will use shld to shift 64-bit integer. VC provides some intrinsics which map to CPU instructions. For example, __ll_lshift will map to shld.

Because the high dword of vl is 0, we can simplify our code:

bool shl_overflow(unsigned long v, int cl)
{
    unsigned long long vl = __ll_lshift(v, cl);
    return (static_cast<unsigned long>(vl >> 32)) != 0;
}

The assembly looks like:

mov     eax, DWORD PTR _v$[esp-4]
mov     ecx, DWORD PTR _cl$[esp-4]
xor     edx, edx
shld    edx, eax, cl
test    edx
jne     overflow

Much better now.

Another approach is based on bit representation.

bool shl_overflow(unsigned long v, int cl)
{
    v = _rotl(v, cl);
    unsigned long index;
    return _BitScanForward(&index, v) ? index >= cl : false;
}

The idea is simple. If v << cl overflows, that means the most significant cl bits of v should contains "1".

There are two ways to test that.

1. Scan v from the least significant bits to the most, and test the index against 32 – cl. However, we have to handle the case when cl = 0.

2. Rotate v cl bits left first, so the most significant cl bits will be the least significant cl bits. Then we can scan and test the index against cl directly.

Notice that, the scan may fail if v is 0. The second way is simpler and more efficient.

The assembly looks like:

mov     ecx, DWORD PTR _cl$[esp-4]
mov     eax, DWORD PTR _v$[esp-4]
rol     eax, cl
bsf     eax, eax
je      notoverflow
cmp     eax, ecx
jl      overflow

It only uses two registers. It can also be extended to handle 64-bit shift. One drawback is an extra conditional jump (The extra jump can be replaced by "cmovz eax, ecx", but there is no way to ask the compiler to generate that)

NOTICE: The technique describes in the article may not be supported in future release of VC. You should not use it in production code

There are two kinds of initialization in C++: static initialization and dynamic initialization.

According to the standard, static initialization shall always be performed before any dynamic initialization takes place.

In VC, static initialization is done at compile time. The value is stored in the data section of the generated executable. On the other hand, dynamic initialization happens at runtime. Before entering main, CRT will call the dynamic initializers of the global variables.

Sometimes you may need to measure the startup time of your program. However, dynamic initialization happens before main, so your measurement will not include it.

This article "CRT Initialization" describes the detailed information of how dynamic initialization works in VC.

VC provides pragma init_seg to fine-control the initialization process. It will place the dynamic initializers in the specific section. Besides predefined compiler, lib and user (the corresponding section names are ".CRT$XCC", ".CRT$XCL" and ".CRT$XCU"), you can also specify the section name explicitly.

With these knowledge, we can use the following code to measure the initialization time of global variables.

Let’s create two files: InitTime_Start.cpp and InitTime_End.cpp (we have to use two files because one file can only have one init_seg)

//InitTime_Start.cpp

#pragma warning(disable : 4075)

#pragma init_seg(".CRT$XCB")

Timer gInitTimer;

//InitTime_End.cpp

#pragma warning(disable : 4075)

#pragma init_seg(".CRT$XCY")

double gInitTime = gInitTimer.GetTime();

Here, "Timer" is a class which will start timing in ctor and return the elapsed time in member function GetTime. Because ".CRT$XCB" will be placed before ".CRT$XCC", the dynamic initializer of the timer will be called before any dynamic initializers of compiler generated global variables. Similarly, gInitTimer.GetTime will be called after all the dynamic initializers of user defined global variables. Then "gInitTime" will contain the initialization time of all global variables including those generated by compiler, library and user.

Object slicing often happens when you pass the object by value. Compiler will do implicitly conversion from derived to base for you without any warning message.

If you want to detect object slicing, you're on your own. However, template can help you.

Because object slicing will call copy constructor of base class, what you can do is to "hijack" it. The magic looks like:

#include <type_traits>
#include "boost\static_assert.hpp"

template<bool>
struct SliceHelper
{
};
template<>
struct SliceHelper<false>
{
    typedef void type;
};
#define DETECTSLICE(NAME,SIZE)\
    enum {_SizeOfClass=SIZE};\
    void _SizeValidation() {BOOST_STATIC_ASSERT(sizeof(NAME)==_SizeOfClass);}\
    template <typename T> NAME(const T &,typename SliceHelper<sizeof(T)==_SizeOfClass || !std::tr1::is_base_of<NAME,T>::value>::type * = 0)\
    {\
        typedef typename T::sliced type;\
    }
struct A
{
    int a;
    A() {}
    DETECTSLICE(A,4)
};
struct B:public A
{
};
struct C:public A
{
    int b;
};
struct D
{
    int a;
};
struct E
{
    int a,b;
};
void f(A) {}
int main()
{
    B b;
    C c;
    D d;
    E e;
    A a;
    A a0(a);
    A a1(b);
    //A a2(c); //error
    //A a3(d); //error
    //A a4(e); //error
    f(a);
    f(b);
    //f(c); //error
    //f(d); //error
    //f(e); //error
}

Notice:

1. The template constructor is not a copy constructor. According to the standard, copy constructor should be non-template. But the template constructor can still be chosen to copy construct the object :-)

2. You can not use sizeof in the member function declaration because the class is incomplete at that point. You can only use sizeof inside the member function definition. That is why we have to specify the size of the class explicitly.

C++0x will be released in the near future. Do you know the changes of standard library? Here is a list of changes that I've collected (minor behavior changes and changes related to concepts are not included).

1. New stuff

system_error:
    new header
array, vector, deque, list, string, map, set, unordered_map, unordered_set:
    new member function: cbegin, cend, crbegin, crend
vector, deque, string:
    new member function: shrink_to_fit
map, unordered_map:
    new member function: at
type_traits:
    new traits:
        is_lvalue_reference, is_rvalue_reference
        has_trivial_default_constructor, has_trivial_copy_constructor, has_nothrow_default_constructor, has_nothrow_copy_constructor
string:
    new type: u16string, u32string
    new function:
        stoi, stol, stoul, stoll, stoull, stof, stod, stold
        to_string, to_wstring
algorithm:
    new function:
        all_of, any_of, none_of, find_if_not, copy_if, partition_copy, is_partitioned, partition_point
        minmax_element
        is_heap_until, is_heap
        is_sorted_until, is_sorted
        next,prev
        min,max,minmax
        copy_n
random:
    new class: seed_seq and many new distributions
    new function: generate_canonical
    new type:
        ranlux24_base, ranlux48_base, ranlux24, ranlux48, knuth_b
        default_random_engine
    For classes linear_congruential, subtract_with_carry, mersenne_twister, discard_block, xor_combine:
        add ctor which accepts seed_seq, member function "seed" and the corresponding _engine class
memory:
    new class: default_delete,unique_ptr
    new function: allocate_shared,make_shared
functional:
    new functor: bit_and, bit_or, bit_xor
numeric:
    new function: iota
iomanip:
    new function:
        get_money, put_money
        get_time, put_time
ios:
    new function: defaultfloat
iosfwd:
    new type: char_traits<char16_t>, char_traits<char32_t>
limits:
    new member function: max_digits10, lowest

2. From tr1

array
unordered_map
unordered_set
regex
random
type_traits
tuple
functional
utility
    get
ios
    hexfloat

3. Other

set, map, unordered_map, unordered_set:
    member function "erase" will have return value (compatible with sequential container)
string:
    pop_back, front, back (compatible with vector)
bitset:
    ctor: unsigned long -> unsigned long long
fstream:
    ctor/open accept string & wstring as the type of filename (C++03 only supports raw string pointer)

MSDN has a page describing various VC extensions. But it is far from complete. 

I've collected a list of nonstandard extensions provided by VC, some of them are evil. If you want to write standard conformant C++ code, you'd better be aware of these extensions which are on by default. Some commonly (mis-)used extensions are in bold.

W4001: nonstandard extension 'single line comment' was used
W4152: nonstandard extension, function/data pointer conversion in expression
W4200: nonstandard extension used : zero-sized array in struct/union
W4201: nonstandard extension used : nameless struct/union
W4202: nonstandard extension used : '...': prototype parameter in name list illegal
W4203: nonstandard extension used : union with static member variable
W4204: nonstandard extension used : non-constant aggregate initializer
W4205: nonstandard extension used : static function declaration in function scope
W4206: nonstandard extension used : translation unit is empty
W4207: nonstandard extension used : extended initializer form
W4208: nonstandard extension used : delete [exp] - exp evaluated but ignored
W4210: nonstandard extension used : function given file scope
W4211: nonstandard extension used : redefined extern to static
W4212: nonstandard extension used : function declaration used ellipsis
W4213: nonstandard extension used : cast on l-value
W4214: nonstandard extension used : bit field types other than int
W4215: nonstandard extension used : long float
W4216: nonstandard extension used : float long
W4218: nonstandard extension used : must specify at least a storage class or a type
W4221: nonstandard extension used : 'identifier' : cannot be initialized using address of automatic variable
W4223: nonstandard extension used : non-lvalue array converted to pointer
W4224: nonstandard extension used : formal parameter 'identifier' was previously defined as a type
W4226: nonstandard extension used : 'keyword' is an obsolete keyword
W4228: nonstandard extension used : qualifiers after comma in declarator list are ignored
W4231: nonstandard extension used : 'identifier' before template explicit instantiation
W4232: nonstandard extension used : 'identifier' : address of dllimport 'dllimport' is not static, identity not guaranteed
W4233: nonstandard extension used : 'keyword' keyword only supported in C++, not C
W4234: nonstandard extension used : 'keyword' keyword reserved for future use
W4235: nonstandard extension used : 'keyword' keyword not supported on this architecture
W4238: nonstandard extension used : class rvalue used as lvalue
W4239: nonstandard extension used : 'token' : conversion from 'type' to 'type'
W4240: nonstandard extension used : access to 'classname' now defined to be 'access specifier', previously it was defined to be 'access specifier'
W4288: nonstandard extension used : 'var' : loop control variable declared in the for-loop is used outside the for-loop scope; it conflicts with the declaration in the outer scope
W4289: nonstandard extension used : 'var' : loop control variable declared in the for-loop is used outside the for-loop scope
W4353: nonstandard extension used: constant 0 as function expression.  Use '__noop' function intrinsic instead
W4480: nonstandard extension used: specifying underlying type for enum 'enum'
W4481: nonstandard extension used: override specifier 'keyword'
W4482: nonstandard extension used: enum 'enum' used in qualified name
W4509: nonstandard extension used: 'function' uses SEH and 'object' has destructor
W4836: nonstandard extension used : 'type' : local types or unnamed types cannot be used as template arguments

C2599: 'enum' : forward declaration of enum type is not allowed

As the designer of base class, you may hesitate whether to use private or protect access control. Then, let's try the following examples:

1. Call protected member function

#include <cstdio>

class A
{
protected:
    void b() {printf("Oops!\n");}
};

void f(A* a)
{
    class A_hack:public A
    {
        friend void f(A*);
    };
    static_cast<A_hack *>(a)->b();
}

class B
{
public:
    void f(A* a)
    {
        class A_hack:public A
        {
            friend B;
        };
        static_cast<A_hack *>(a)->b();
    }
};

int main()
{
    f(NULL);
    B().f(NULL);
}

Although the result of the cast is undefined as stated in the standard, if no this pointer adjustment happens and the layout of A is the same as A_hack which are normally the case, the code will break the access control.

For the evil user, his purpose is archieved.

2. Call pure virtual function

class A
{
protected:
    virtual void Fun() =0;
};

class B:public A
{
public:
    B() {Dummy();}

private:
    void Dummy() {Fun();}
};
class C:public B
{
public:
    virtual void Fun() {}
};

int main()
{
    C c;
}

Do you ever wonder how to call pure virtual function? Do you like to see what does _purecall in VC do? Just try the above code.

The problem here is because of the protect access of "Fun" in base class. Of course, you should not call virtual function in ctor (they will not have polymorphic behavior), but when you call Dummy in ctor, you may not realize the fact that Dummy will call virtual function internally. Then the disaster happens.

If what you want by using virtual is to allow the derived class to provide some specific behavior, you'd better declare the function as private.

Although both the above code are nonconformant, they at least show the possibility that your user can do more than what you expect for protect.

If you don't even have confidence with private (Like evil #define private public which definitely violates One Definition Rule), you'd better use the PImpl Idiom to implement your interface.