int i = 0;

    int i(0);

    std::complex x = x0;

    std::complex x(x0);

Prefer using the form "T t(u);" instead of "T t = u;" where possible. The former usually works wherever the latter works, and has other advantages—for example, it can take multiple parameters.

(Herb Sutter, Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions, Item 42)

B>Ну, может быть что-то вроде этого: если Вы боитесь создания лишнего временного объекта — используйте вариант со скобками.

int sum(int const a[], std::size_t const a_length)
{
    int sum(0);
    int const* const a_end(a + a_length);
    for (int const* p(a); p < a_end; ++p)
        sum += *p;
    return sum;
}

Prefer using the form "T t(u);" instead of "T t = u;" where possible. The former usually works wherever the latter works, and has other advantages—for example, it can take multiple parameters.

(Herb Sutter, Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions, Item 42)

If u is of some other type, then this has the meaning "T t( T(u) );"—that is, u is first converted to a temporary T object, and then t is copy-constructed from that.

#include <iostream>

struct X
{
    X(X const *)
        { std::cout << "X(X const *)" << std::endl; }
    X(X &)
        { std::cout << "X(X &)" << std::endl; }
    operator X const *() const
        { std::cout << "X::operator X const *()"; return this; }
    ~X()
        {}
};

int main()
{
    X x(X(0));
}

X x(X(0));

X x = 0;

struct X;

struct A
{
    operator X const &() const;
};

struct X
{
    X(X &);
    template <class T>
        X(T const &);
};

int f(X);

int main()
{
    sizeof f(A());
}

struct X;

struct A
{
    operator X &() const;
};

struct X
{
    X(X &);
private:
    template <class T>
        X(T const &);
};

int f(X);

int main()
{
    sizeof f(A());
}

#include <iostream>

struct X
{
    explicit X(int)
        { std::cout << "X(int)" << std::endl; }
    X(long)
        { std::cout << "X(long)" << std::endl; }
};

int main()
{
    X x1 = 0;
    X x2(X(0));
}

I>    int i = 0;
I>

I>    int i(0);
I>

    int i = int(); // о как!

W>    int i = int(); // о как!

typedef int T;
typedef int u;

T t(T(u));

T (*pointer_to_function)(T f(u)) = &t;

#include <iostream>

typedef int T;
bool u;

int main()
{
    T t( T(u) ); // эквивалентно T t(T u); или просто T t(T);
    std::cout << sizeof t(0) << std::endl;
}

I>    int i = 0;
I>

I>    int i(0);
I>

int i(10);
int i[10];

W>>В условии увидел только нули, отсюда и вариант

    std::string str = "string";

    std::string str("string");

fay>int i(10);
fay>int i[10];

    int const n(123);

fay>>int i(10);
fay>>int i[10];
I>

void test ( void *a );
int i1(10);
int i2[10];

test(&i1);
test(&i2);

E>да

   int const n(123);

std::complex<double> clVar( 3.0, -1.0 );
std::auto_ptr<MyStock> pStock( new MyStock( 12, 15, L"Выдача" ) );
boost::shared_array<wchar_t>( new wchar_t[MaxFileLen] );

std::wstring strSQL( L"select IDW,WNAME "
                     L"from WAREHOUSE "
                     L"where OWNER=[:owner]" );
std::wstring strOwner;
if( bla...bla )
   strOwner = L"admin";
else
   strOwner = L"user";

fay>std::complex<double> clVar( 3.0, -1.0 );

    std::complex<double> x(y);

    std::complex<double> x = y;

fay>Специально глянул в исходники — как пальцы стали, так и написал

fay>std::wstring strSQL( L"select IDW,WNAME "
fay>                     L"from WAREHOUSE "
fay>                     L"where OWNER=[:owner]" );
fay>std::wstring strOwner;
fay>if( bla...bla )
fay>   strOwner = L"admin";
fay>else
fay>   strOwner = L"user";

E>А что, std::vector<const int> уже запрещён?..

#include <vector>
using namespace std;

vector<const int> v;

fay>>std::complex<double> clVar( 3.0, -1.0 );
I>

I>    std::complex<double> x(y);
I>

I>    std::complex<double> x = y;
I>

std::complex<double> x( 3.0, -1.0 );

std::complex<double> x = y;

fay>>Специально глянул в исходники — как пальцы стали, так и написал

fay>>std::wstring strSQL( L"select IDW,WNAME "
fay>>                     L"from WAREHOUSE "
fay>>                     L"where OWNER=[:owner]" );
fay>>std::wstring strOwner;
fay>>if( bla...bla )
fay>>   strOwner = L"admin";
fay>>else
fay>>   strOwner = L"user";
I>

std::wstring strOwner( ((bal..bla) ? L"admin" : L"user") );

fay>std::wstring strOwner( ((bal..bla) ? L"admin" : L"user") );

fay>Но мне эта запись глаза режет.

std::wstring strOwner = (bal..bla) ? L"admin" : L"user";

    string s = "abcd";

void f(char const* p)
{
    string s = p;
}

I>    string s = "abcd";
I>

I>void f(char const* p)
I>{
I>    string s = p;
I>}
I>

string s = string( x, y, z );

string s = string( x, y, z );

    string s = string( "abcd" );

I>для единообразия.

double x = double( 5 );

fay>>std::wstring strOwner( ((bal..bla) ? L"admin" : L"user") );
I>

fay>>Но мне эта запись глаза режет.

I>std::wstring strOwner = (bal..bla) ? L"admin" : L"user";
I>

int main( int argc, char **, char ** ) {
   std::wstring str1;
   if( argc )
      str1 = L"123";   
   else
      str1 = L"456";   

   std::wcout << str1 << std::endl;

   std::wstring str2 = (argc) ? L"678"
                              : L"012";   

   std::wcout << str2 << std::endl;

   return 0;
}

; 231  :    if( argc )
   mov   edi, DWORD PTR _argc$[esp+84]
   mov   DWORD PTR __$EHRec$[esp+96], ebx

; 232  :       str1 = L"123";   
   push  3
   lea   ecx, DWORD PTR _str1$[esp+92]
   cmp   edi, ebx
   je SHORT $LN2@main
   push  OFFSET $SG155640

; 233  :    else
   jmp   SHORT $LN160@main
$LN2@main:

; 234  :       str1 = L"456";   
   push  OFFSET $SG155642
$LN160@main:
   call  ?assign@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAEAAV12@PB_WI@Z ; std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >::assign

; 237  : 
; 238  :    std::wstring str2 = (argc) ? L"678"
; 239  :                               : L"012";   
   mov   edx, OFFSET $SG155682
   cmp   edi, ebx
   jne   SHORT $LN6@main
   mov   edx, OFFSET $SG155683
$LN6@main:
   xor   eax, eax
   mov   WORD PTR _str2$[esp+92], ax
   mov   eax, edx
   mov   DWORD PTR _str2$[esp+112], 7
   mov   DWORD PTR _str2$[esp+108], ebx
   lea   esi, DWORD PTR [eax+2]
$LL157@main:
   mov   cx, WORD PTR [eax]
   add   eax, 2
   cmp   cx, bx
   jne   SHORT $LL157@main
   sub   eax, esi
   sar   eax, 1
   push  eax
   push  edx
   lea   ecx, DWORD PTR _str2$[esp+96]
   call  ?assign@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAEAAV12@PB_WI@Z ; std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >::assign

    vector<int> a = 10;

#include <iostream>

struct X
{
    X(X const *)
        { std::cout << "X(X const *)" << std::endl; }
    X(X &)
        { std::cout << "X(X &)" << std::endl; }
    operator X const *() const
        { std::cout << "X::operator X const *()"; return this; }
    ~X()
        {}
};

int main()
{
    X x(X(0));
}

X x(X(0));

X x = 0;

However, when considering the argument of a user-defined conversion function that is a candidate by 13.3.1.3 when invoked for the copying of the temporary in the second step of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or 13.3.1.6 in all cases, only standard conversion sequences and ellipsis conversion sequences are allowed.