int * i=NULL;

i=new int[5]={1,2,3};

А>i=new int[5]={1,2,3};
А>

template<typename T, typename TIter>
void initWith( std::vector<T>&dst, int dstCount, TIter from, TIter to )
{
    assert( dstCount >= 0 );
    dst.clear();
    dst.reserve( dstCount );
    int count = 0;
    for( TIter i = from; i != to; ++i ) {
        assert( dstCount >= ++count );
        dst.push_back( *i );
    }
    dst.resize( dstCount );
}
template<typename T, typename TIter>
void initWith( std::vector<T>&dst, int dstCount, TIter from, int initCount )
{
    initWith( dst, dstCount, from, from+initCount );
}

void foo() 
{
    std::vector<int> array;
    static const int initValues[] = { 1, 2, 3 };
    initWith( array, 5, initValues, lengthof( values ) );
}

In C, it has been popular to define a macro NULL to represent the zero pointer. Because of
C++’s tighter type checking, the use of plain 0, rather than any suggested NULL macro, leads to
fewer problems. If you feel you must define NULL , use
const int NULL = 0 ;
The const qualifier (§5.4) prevents accidental redefinition of NULL and ensures that NULL can be
used where a constant is required.

template<typename T, typename TIter>
E>void initWith( std::vector<T>&dst, int dstCount, TIter from, TIter to )
E>{
E>    assert( dstCount >= 0 );
E>    dst.clear();
E>    dst.reserve( dstCount );
E>    int count = 0;
E>    for( TIter i = from; i != to; ++i ) {
E>        assert( dstCount >= ++count );
E>        dst.push_back( *i );
E>    }
E>    dst.resize( dstCount );
E>}
E>template<typename T, typename TIter>
E>void initWith( std::vector<T>&dst, int dstCount, TIter from, int initCount )
E>{
E>    initWith( dst, dstCount, from, from+initCount );
E>}

E>void foo() 
E>{
E>    std::vector<int> array;
E>    static const int initValues[] = { 1, 2, 3 };
E>    initWith( array, 5, initValues, lengthof( values ) );
E>}

#define ARRAY_LENGTH(x) sizeof(x) / sizeof(x[0])

void foo()
{
  static const int initValues[] = { 1, 2, 3 };
  std::vector<int> array(initValues, initValies + ARRAY_LENGTH(initValues));
}

7.17 Common definitions <stddef.h>
3 The macros are
NULL
which expands to an implementation-defined null pointer constant

void fun1 ( )
{
004026B0 83 EC 1C         sub         esp,1Ch 
004026B3 53               push        ebx  
004026B4 55               push        ebp  
004026B5 56               push        esi  
004026B6 57               push        edi  
    vector<int> iv(0x1000);
004026B7 8D 7C 24 14      lea         edi,[esp+14h] 
004026BB 8D 74 24 18      lea         esi,[esp+18h] 
004026BF C7 44 24 14 00 00 00 00 mov         dword ptr [esp+14h],0 
004026C7 E8 F4 12 00 00   call        std::vector<int,std::allocator<int> >::_Construct_n (4039C0h) 

    for ( size_t jv=0; jv<0x1000; jv++ )
004026CC 8B 5C 24 20      mov         ebx,dword ptr [esp+20h] 
004026D0 8B 7C 24 1C      mov         edi,dword ptr [esp+1Ch] 
004026D4 8B 2D FC A0 40 00 mov         ebp,dword ptr [__imp___invalid_parameter_noinfo (40A0FCh)] 
004026DA 33 F6            xor         esi,esi 
004026DC 8D 64 24 00      lea         esp,[esp] 
        iv[jv]=2;
004026E0 85 FF            test        edi,edi 
004026E2 74 0B            je          fun1+3Fh (4026EFh) 
004026E4 8B C3            mov         eax,ebx 
004026E6 2B C7            sub         eax,edi 
004026E8 C1 F8 02         sar         eax,2 
004026EB 3B F0            cmp         esi,eax 
004026ED 72 02            jb          fun1+41h (4026F1h) 
004026EF FF D5            call        ebp  
004026F1 C7 04 B7 02 00 00 00 mov         dword ptr [edi+esi*4],2 
004026F8 83 C6 01         add         esi,1 
004026FB 81 FE 00 10 00 00 cmp         esi,1000h 
00402701 72 DD            jb          fun1+30h (4026E0h) 

}
00402703 85 FF            test        edi,edi 
00402705 74 09            je          fun1+60h (402710h) 
00402707 57               push        edi  
00402708 E8 6D 69 00 00   call        operator delete (40907Ah) 
0040270D 83 C4 04         add         esp,4 
00402710 5F               pop         edi  
00402711 5E               pop         esi  
00402712 5D               pop         ebp  
00402713 5B               pop         ebx  
00402714 83 C4 1C         add         esp,1Ch 
00402717 C3               ret              
--- No source file -------------------------------------------------------------
00402718 CC               int         3    
00402719 CC               int         3    
0040271A CC               int         3    
0040271B CC               int         3    
0040271C CC               int         3    
0040271D CC               int         3    
0040271E CC               int         3    
0040271F CC               int         3    
--- 11.cpp -----------------------------
void fun2 ()
{
    int i[0x1000];

    for ( size_t j=0; j<0x1000; j++ )
        i[j]=2;

}
int _tmain ( int argc, _TCHAR* argv[] )
{
00402720 55                        push        ebp  
00402721 8B EC                   mov         ebp,esp 
00402723 83 E4 F8               and         esp,0FFFFFFF8h 
00402726 6A FF                   push        0FFFFFFFFh 
00402728 68 96 9C 40 00      push        offset __ehhandler$_wmain (409C96h) 
0040272D 64 A1 00 00 00 00 mov         eax,dword ptr fs:[00000000h] 
00402733 50                        push        eax  
00402734 83 EC 60              sub         esp,60h 
00402737 53                        push        ebx  
00402738 56                        push        esi  
00402739 57                        push        edi  
0040273A A1 1C 10 41 00     mov         eax,dword ptr [___security_cookie (41101Ch)] 
0040273F 33 C4                   xor         eax,esp 
00402741 50                        push        eax  
00402742 8D 44 24 70          lea         eax,[esp+70h] 
00402746 64 A3 00 00 00 00 mov         dword ptr fs:[00000000h],eax 


    fun1();
0040274C E8 5F FF FF FF   call        fun1 (4026B0h) 
    fun2();

...

#include <vector>

void fun1 ( )
{
    vector<int> iv(0x1000);

    for ( size_t jv=0; jv<0x1000; jv++ )
        iv[jv]=2;

}
void fun2 ()
{
    int i[0x1000];

    for ( size_t j=0; j<0x1000; j++ )
        i[j]=2;

}
int _tmain ( int argc, _TCHAR* argv[] )
{

    fun1();
    fun2();
}

template<typename T, int N> T* newInitedArray( int count, const T (&src)[N] )
{
    T* res = new[count];
    if( count > N )
        count = N;
    for( int i = 0; i < count; i++ )
        res[i] = src[i];
    return res;
}

void foo()
{
    int patt[] = { 1, 2, 3 };
    int* newI = newInitedArray( 5, patt );
}

template<typename T>
class ArrayCreator {
    enum { maxDataCount = 3 };
    enum { useDataCount = -1 };
public:
    ArrayCreator() { init( 0 ); }
    ArrayCreator( const T& a1 ) { init( 1, &a1 ); }
    ArrayCreator( const T& a1, const T& a2 ) { init( 2, &a1, &a2 ); }
    ArrayCreator( const T& a1, const T& a2, const T& a3 ) { init( 3, &a1, &a2, &a3 ); }
    //...

    const T* Begin() const { return data; }
    const T* End() const { return data + dataCount; }

    T* NewArray( int count = useDataCount );
    std::vector<T> CreateVector( int count = useDataCount );

    void Init( T* dst, int count );
    void Init( std::vector<T>& dst, int count = useDataCount );
    template<int N>
    voiud Init( T (&dst)[N] ); 
private:
    T data[maxDataCount];
    int dataCount;

    void init( int dCount, ... )
    //...
};

vpod foo()
{
    int* p = ArrayCreator<int>( 1, 2, 3 ).NewArray( 5 );
}

А>>Да эта форма инициализации, мне инвестна. Можно даже вроде не только '()' но и (33)

L_L>А по поводу неудобства инициализации — есть такое. Видимо, в будущем это пофиксят при помощи нового синтаксиса инициализаторов для стандартных контейнеров или пользовательских классов. Синтаксиса не помню, но что нить вроде std::vector<int> a = {1,2,3,4,5};

 int *i=new int(0x33);

B>>#define ARRAY_LENGTH(x) sizeof(x) / sizeof(x[0])

B>>void foo()
B>>{
B>>  static const int initValues[] = { 1, 2, 3 };
B>>  std::vector<int> array(initValues, initValies + ARRAY_LENGTH(initValues));
B>>}
B>>

E>Этот код делает другое...

void foo()
{
  static const int initValues[] = { 1, 2, 3 };
  std::vector<int> array(5);
  array.insert(array.begin(), initValues, initValies + ARRAY_LENGTH(initValues));
}

void foo( void* );
void foo( int );

void bar()
{
    int i = 0;
    int* p = 0;

    void (*Pf)( int ) = foo;
}

E>>Страуструп, кстати, вряд ли идиот, в отличии от некоторых коллег...

А>> int *i=new int(0x33);
А>>

А>>Прекрасно работает.

Нет, как и сказал Андрей, только ().

А, т.е. вы не понимаете разницу между вектором и встроенным массивом? Ну-ну.

А>Все мне надо работать, а не заниматься выигрыванием спров...

очень смешно — но как Вы себе представляете отличить один ноль от другого? '0' — вот этот ноль уж будьте любезны трактовать как 0 интовый, а вот этот '0' , как указатель на 0x123412344321AB00 ...

Вперед.

Стратус пишет книжки для чайников, Вы чайники?

  fun1();
0040111D  xor         ebp,ebp 
0040111F  lea         edi,[esp+18h] 
00401123  lea         esi,[esp+20h] 
00401127  mov         dword ptr [esp+18h],ebp 
0040112B  call        std::vector<int,std::allocator<int> >::_Construct_n (401250h) 
00401130  mov         edx,dword ptr [esp+24h] 
00401134  cmp         edx,ebp 
00401136  mov         ecx,1000h 
0040113B  mov         eax,2 
00401140  mov         edi,edx 
00401142  rep stos    dword ptr es:[edi] 
00401144  je          main+5Fh (40114Fh) 
00401146  push        edx  
00401147  call        operator delete (40190Ah) 
0040114C  add         esp,4 
  fun2();
0040114F  push        4000h 
00401154  call        operator new[] (4018EAh) 
00401159  mov         edx,eax 
0040115B  add         esp,4 
0040115E  mov         eax,2 
00401163  mov         edi,edx 
00401165  mov         ecx,1000h 
0040116A  push        edx  
0040116B  rep stos    dword ptr es:[edi] 
0040116D  call        operator delete (40190Ah) 
00401172  add         esp,4

А>Это чьи слова ? Правильно, ваши. Вы оказались не правы, а мне на вид ставили.

Андрей Тарасевич:

Для 'new[]' поддерживается только один вид инициализатора: '()'. Т.е. можно сделать 'i = new int[5]()' и получить обнуленный массив в результате. Других иницализаторов не поддерживается, т.е. "инициализацию" придется делать потом присваиванием

Вы:
Да эта форма инициализации, мне инвестна. Можно даже вроде не только '()' но и (33)

Нет, как и сказал Андрей, только ().

А>Я понимаю,

#include <vector>

void _fastcall fun1 ( vector<int> * piv )
{
00402690 53               push        ebx  
    for ( register size_t jv=0; jv<0x1000; jv++ )
00402691 8B 1D FC B0 40 00 mov         ebx,dword ptr [__imp___invalid_parameter_noinfo (40B0FCh)] 
00402697 56               push        esi  
00402698 33 F6            xor         esi,esi 
0040269A 8D 9B 00 00 00 00 lea         ebx,[ebx] 
        (*piv)[jv]=2;
004026A0 8B 4F 04         mov         ecx,dword ptr [edi+4] 
004026A3 85 C9            test        ecx,ecx 
004026A5 74 0C            je          fun1+23h (4026B3h) 
004026A7 8B 47 08         mov         eax,dword ptr [edi+8] 
004026AA 2B C1            sub         eax,ecx 
004026AC C1 F8 02         sar         eax,2 
004026AF 3B F0            cmp         esi,eax 
004026B1 72 02            jb          fun1+25h (4026B5h) 
004026B3 FF D3            call        ebx  
004026B5 8B 47 04         mov         eax,dword ptr [edi+4] 
004026B8 C7 04 B0 02 00 00 00 mov         dword ptr [eax+esi*4],2 
004026BF 83 C6 01         add         esi,1 
004026C2 81 FE 00 10 00 00 cmp         esi,1000h 
004026C8 72 D6            jb          fun1+10h (4026A0h) 
004026CA 5E               pop         esi  
004026CB 5B               pop         ebx  

}
004026CC C3               ret              
--- No source file -------------------------------------------------------------
004026CD CC               int         3    
004026CE CC               int         3    
004026CF CC               int         3    
--- d:\new my projects\mql2cpp\mql2cpp\mql2cpp.cpp -----------------------------
void _fastcall fun2 ( int * pi)
{
    for ( register size_t j=0; j<0x1000; j++ )
        pi[j]=2;
}
int _tmain ( int argc, _TCHAR* argv[] )
{
004026D0 55               push        ebp  
004026D1 8B EC            mov         ebp,esp 
004026D3 83 E4 F8         and         esp,0FFFFFFF8h 
004026D6 6A FF            push        0FFFFFFFFh 
004026D8 68 8E A2 40 00   push        offset __ehhandler$_wmain (40A28Eh) 
004026DD 64 A1 00 00 00 00 mov         eax,dword ptr fs:[00000000h] 
004026E3 50               push        eax  
004026E4 64 89 25 00 00 00 00 mov         dword ptr fs:[0],esp 
004026EB 83 EC 70         sub         esp,70h 
004026EE 53               push        ebx  
004026EF 56               push        esi  
004026F0 57               push        edi  
    vector<int> iv(0x1000);
004026F1 33 DB            xor         ebx,ebx 
004026F3 8D 7C 24 28      lea         edi,[esp+28h] 
004026F7 8D 74 24 68      lea         esi,[esp+68h] 
004026FB 89 5C 24 28      mov         dword ptr [esp+28h],ebx 
004026FF E8 AC 12 00 00   call        std::vector<int,std::allocator<int> >::_Construct_n (4039B0h) 
    int i[0x1000];
    fun1( &iv );
00402704 8B FE            mov         edi,esi 
00402706 89 9C 24 84 00 00 00 mov         dword ptr [esp+84h],ebx 
0040270D E8 7E FF FF FF   call        fun1 (402690h) 
    fun2( i );

#include <vector>

void _fastcall fun1 ( vector<int> * piv )
{
    for ( register size_t jv=0; jv<0x1000; jv++ )
        (*piv)[jv]=2;

}
void _fastcall fun2 ( int * pi)
{
    for ( register size_t j=0; j<0x1000; j++ )
        pi[j]=2;
}
int _tmain ( int argc, _TCHAR* argv[] )
{
    vector<int> iv(0x1000);
    int i[0x1000];
    fun1( &iv );
    fun2( i );
}

/O2 /Oy /GL /I "." /D "_CRT_SECURE_NO_DEPRECATE=1" /D "_UNICODE" /D "UNICODE" /FD /EHsc /MD /GS- /arch:SSE2 /Zc:wchar_t- /Fo"Release\\" /Fd"Release\vc80.pdb" /W3 /nologo /c /Wp64 /Zi /TP /errorReport:prompt

А>>>О люди, хочу что-бы народ извинился.

А>>>... многа бреда поскипано.
А>>>

А>Бреда? : ) Люди, ну остановитесь же — вы невладете вопросом, это был релиз... Представляю как Вы огорошены. Но я рад....

#include <Windows.h>
#include <iostream>

#include <vector>

using namespace std;

void fun1 (vector<int>& iv)
{    
  for ( size_t jv=0; jv<0x1000; jv++ )
    iv[jv]=jv;

}
void fun2 (int* i)
{
  for ( size_t j=0; j<0x1000; j++ )
    i[j]=j;
}
int _tmain ( int argc, _TCHAR* argv[] )
{
  vector<int> iv(0x1000);
  int* ia = new int[0x1000];

  DWORD initTime = GetTickCount();

  for (int i=0; i<10000; ++i)
    fun1(iv);

  DWORD timeFun1 = GetTickCount();

  for (int j=0; j<10000; ++j)
    fun2(ia);

  DWORD timeFun2 = GetTickCount();

  delete []ia;

  cout << "time(fun1)=" << timeFun1 - initTime << endl;
  cout << "time(fun2)=" << timeFun2 - timeFun1 << endl;
}

 for (int i=0; i<10000; ++i)
    fun1(iv);
00401081  xor         esi,esi 
00401083  mov         eax,dword ptr [esp+28h] 
00401087  sub         eax,dword ptr [esp+24h] 
0040108B  sar         eax,2 
0040108E  cmp         esi,eax 
00401090  jb          wmain+94h (401094h) 
00401092  call        ebp  

00401094  mov         ecx,dword ptr [esp+24h] 
00401098  mov         dword ptr [ecx+esi*4],esi 
0040109B  inc         esi  
0040109C  cmp         esi,1000h 
004010A2  jb          wmain+83h (401083h)

  for (int j=0; j<10000; ++j)
    fun2(ia);
004010B8  xor         ebp,ebp 
004010BA  xor         eax,eax 
004010BC  lea         esp,[esp] 
004010C0  mov         dword ptr [ebx+eax*4],eax 
004010C3  inc         eax  
004010C4  cmp         eax,1000h 
004010C9  jb          wmain+0C0h (4010C0h)

#define _SECURE_SCL  0
#undef _HAS_ITERATOR_DEBUGGING

 for (int i=0; i<10000; ++i)
    fun1(iv);
00401060  xor         eax,eax 
00401062  mov         dword ptr [edi+eax*4],eax 
00401065  inc         eax  
00401066  cmp         eax,1000h 
0040106B  jb          wmain+62h (401062h)

00402691 8B 1D FC B0 40 00 mov         ebx,dword ptr [__imp___invalid_parameter_noinfo (40B0FCh)] 
00402697 56               push        esi  
00402698 33 F6            xor         esi,esi 
0040269A 8D 9B 00 00 00 00 lea         ebx,[ebx] 
        (*piv)[jv]=2;
004026A0 8B 4F 04         mov         ecx,dword ptr [edi+4] 
004026A3 85 C9            test        ecx,ecx 
004026A5 74 0C            je          fun1+23h (4026B3h) 
004026A7 8B 47 08         mov         eax,dword ptr [edi+8] 
004026AA 2B C1            sub         eax,ecx 
004026AC C1 F8 02         sar         eax,2 
004026AF 3B F0            cmp         esi,eax 
004026B1 72 02            jb          fun1+25h (4026B5h) 
004026B3 FF D3            call        ebx

#include <vector>

void _fastcall fun1 ( vector<int> * piv )
{
    for ( register size_t jv=0; jv<0x1000; jv++ )
        (*piv)[jv]=2;

}
void _fastcall fun2 ( int * pi)
{
    for ( register size_t j=0; j<0x1000; j++ )
        pi[j]=2;
}
int _tmain ( int argc, _TCHAR* argv[] )
{
    vector<int> iv(0x1000);
    int i[0x1000];

    LARGE_INTEGER t0,t1,t2,f;

    QueryPerformanceCounter(&t0);
    fun1( &iv );
    QueryPerformanceCounter(&t1);
    fun2( i );
    QueryPerformanceCounter(&t2);
    
    QueryPerformanceFrequency(&f);

    double d1=(t1.QuadPart-t0.QuadPart);
    double d2=(t2.QuadPart-t1.QuadPart);
    
    d1=d1/f.QuadPart;
    d2=d2/f.QuadPart;

    //t1-t0

    printf("\nt1:%22.18e sec\nt2:%22.18e sec",d1,d2);
    printf("\nt1:%44.40f sec\nt2:%44.40f sec",d1,d2);
    double d3=d1/d2;
    int i3=d3+0.5;
    printf("\n%f (%d) times. ;-)",d3,i3);
}

t1:2,142027750628607600e-005 sec
t2:5,880927916865064700e-007 sec
t1: 0,0000214202775062860760000000000000000000 sec
t2: 0,0000005880927916865064700000000000000000 sec
36.423295 (36) times.

А>Ок, раз уж пошла такая пьянка, то давай померяем время.

#define _SECURE_SCL 0

А>ДА РАЗБЕРИТЕСЬ ЖЕ УЖЕ НАКОНЕЦ!!! люди — ВЫ НЕ ИНДУСЫ. !!!

  LARGE_INTEGER t0,t1,t2,f;

  QueryPerformanceCounter(&t0);
00401046  lea         eax,[esp+54h] 
0040104A  mov         dword ptr [esp+0C0h],ebx 
00401051  mov         esi,dword ptr [__imp__QueryPerformanceCounter@4 (402000h)] 
00401057  push        eax  
00401058  call        esi  
  fun1( &iv );
0040105A  mov         ebx,dword ptr [esp+78h] 
0040105E  mov         eax,2 
00401063  mov         ecx,1000h 
00401068  mov         edi,ebx 
0040106A  rep stos    dword ptr es:[edi] 
  QueryPerformanceCounter(&t1);
0040106C  lea         ecx,[esp+4Ch] 
00401070  push        ecx  
00401071  call        esi  
  fun2( i );
  QueryPerformanceCounter(&t2);
00401073  lea         edx,[esp+5Ch] 
00401077  push        edx  
00401078  call        esi

А>>Код на столе, а вы где? ... Троль... хм, просто позорище.

Мне кажется, вам пора остановиться.