Здравствуйте, Lorenzo_LAMAS, Вы писали:

А>>У меня в архитектуре int 32 бита а указатель ( это адрес, для скриптовиков ) 128 бит. И что? '0' это 0... У меня по адресу ноль есть данные... Что дальше? Ваш неучь Страуструп нихрена не понимает вообще в СИ и СИ++... Перестаньте читать идиотов.

L_L>Следуя вашему совету, я не должен был читать вашего дико бредового сообщения. Простите за грубость, конечно, но не пишите фигню и не указывайте мне, кого мне читать, а кого — нет. Я уж как-нибудь сам разберусь.
L_L>Чисто для справки, не знаю, сколько вам лет, но уверен, что Страуструп знал С тогда, когда вас на свете еще не было.

Да и бог с ним. Он пишет БРЕД. Ноль это 0, NULL это не существующий адрес, зависящий от архитекуры. И что? Это факт, Ваш Стратус написал вранье, а сколько его там, кроме этого, уже и не вспомню. Но просто убогий писатель. Деньги зарабатываает тем что пишет книжки, но предмета не знает. Это факт.

А>Ваш Стратус написал вранье, а сколько его там, кроме этого, уже и не вспомню. Но просто убогий писатель. Деньги зарабатываает тем что пишет книжки, но предмета не знает. Это факт.

Скажите, это вы так шутите/троллите своеобразно?

А>Да и бог с ним. Он пишет БРЕД. Ноль это 0, NULL это не существующий адрес, зависящий от архитекуры.
Вы точно знаете, что такое NULL? Как настоящий знаток С, не чета Страуструпу, стандарт С вы читали?

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

слова null pointer constant вам что-то говорят?

Здравствуйте, Аноним, Вы писали:

А>Неверные разультаты , Причем заметьте, я даже и топик не читал — так как подругому и быть не может. 1000%

Вектор выделяет память одним куском. Поэтому реальный объем памяти который потребляет вектор будет складываться из следующих параметров:
capacity — количество заразервированных байт (capacity() >= length())
значение length (sizeof(size_t)) — текущий размер вектора
значение capacity (sizeof(size_t)) — текущее значение capacity
и все!!!

Причем если для вектора взять указатель на первый элемент &array[0] то с ним можно работать как с простым массивом. И стандарт это ГАРАНТИРУЕТ!!!
Замедления работы через operator[] связаны с тем, что в дебажном режиме компиляции стл делает дополнительные проверки, которые отсутствуют в релизе. Поэтому релизный operator [] ничем не отличается от обращения к элементу сишного массива.
Так что поучил бы сначала матчасть, и тесты бы погонял, а потом уж делал такие заявления.

А>Скорость работы с такими массивами

А>int i[100];

А>и vector<int> iv;

А>Различается в дестяки раз. А памяти лишней сколько жрется.

IMHO анонимов неплохо бы запретить и в профильных форумах.

Здравствуйте, Аноним, Вы писали:

А>Скорость работы с такими массивами

А>int i[100];

А>и vector<int> iv;

А>Различается в дестяки раз. А памяти лишней сколько жрется.

Код в студию.
Померяем вместе.

You will always get what you always got
  If you always do  what you always did

Здравствуйте, Аноним, Вы писали:

А>>>

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

E>>Не совсем понятно, "5" в этом коде -- константа? А "1, 2, 3"--?
E>>И типы какие? Стандартные или классы?

E>>В общем случае, если ты STL пользуешься, то можно как-то так:

template<typename T, typename TIter>

А>Совсем народ от этох "надстроек" отупел. :) 
Повежливее бы, что ли...

А>Какие типы - int. :) 
Ну из вопроса топикстартера не понятно какие типы... 

А>Вектора, и пр. щит, не подходит - медленно.
Да? А можешь пояснить в чём разница между [c]std::vector<int> v;
v.reserve( 5 );

и new int[5]?

Кстати, так, как хочет автор в "чистом С++" нельзя...

А>Перестаньте использовать то чего не понимаете, начните отличаться, от индусов.

Ах, мне вот тоже STL не нравится. Но чтобы не использовать надо таки понимать почему не используешь...

Здравствуйте, catBasilio, Вы писали:

B>Зачем так сложно?

B>

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>

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

Здравствуйте, jazzer, Вы писали:

J>Здравствуйте, Аноним, Вы писали:

А>>Скорость работы с такими массивами

А>>int i[100];

А>>и vector<int> iv;

А>>Различается в дестяки раз. А памяти лишней сколько жрется.

J>Код в студию.
J>Померяем вместе.



наслаждайтесь ...

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

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();
}

Здравствуйте, Аноним, Вы писали:

А>У меня в архитектуре int 32 бита а указатель ( это адрес, для скриптовиков ) 128 бит. И что? '0' это 0... У меня по адресу ноль есть данные... Что дальше? Ваш неучь Страуструп нихрена не понимает вообще в СИ и СИ++...

И то, что ты не знаешь С++.
В С++ 0 -- это литерал, который может обозначать интегральный 0, а может и нулевой указатель. Бинарное представление нулевого указателя при этом может быть каким угодно. На многих архитектурах, кстати, указатели вообще имеют более сложную структуру, чем одно число...


А>Перестаньте читать идиотов.
Ну они всё пишут и пишут... Случайно можно и прочитать...
Страуструп, кстати, вряд ли идиот, в отличии от некоторых коллег...

Здравствуйте, igna, Вы писали:

I>IMHO анонимов неплохо бы запретить и в профильных форумах.

Так плохо, так как вопрос задать будет сложнее

Можно по IP, например, банить.
А можно просто выделять сообщения от подозрительных ip. Либо иметь опцию "не показывать сообщения от анонимов, и всё, что растёт из них"...

Ну, либо "огонь! безжалостный огонь!"
Я бы вот бомбу повесил, но опасаюсь кар модераторов...

Здравствуйте, Erop, Вы писали:

А>>У меня в архитектуре int 32 бита а указатель ( это адрес, для скриптовиков ) 128 бит. И что? '0' это 0... У меня по адресу ноль есть данные... Что дальше? Ваш неучь Страуструп нихрена не понимает вообще в СИ и СИ++...

E>И то, что ты не знаешь С++.
E>В С++ 0 -- это литерал, который может обозначать интегральный 0, а может и нулевой указатель. Бинарное представление нулевого указателя при этом может быть каким угодно. На многих архитектурах, кстати, указатели вообще имеют более сложную структуру, чем одно число...


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

Вперед.

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

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

Да, не идиот, я не прав. Извини Статус.

E>Я бы вот бомбу повесил, но опасаюсь кар модераторов...
А почему? Я — нет. Вешаю.

Здравствуйте, Lorenzo_LAMAS, Вы писали:

E>>Я бы вот бомбу повесил, но опасаюсь кар модераторов...
L_L>А почему? Я — нет. Вешаю.

Сдались... Скриптовики... ха-ха...

здесь

Автор:
Дата: 07.04.09

я привел пример того как вы заблуждаетесь, и насколько вы не понимаете то что используете.!!!

Давафате дебангалориться, пора уже...

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

А почему у вас вектор сравнивается со стековым массивом, а не с массивом в динамической памяти?

Здравствуйте, Аноним, Вы писали:

А>Да похоже что никак. Жаль. Придется потрахаться немного по больше.

А что у тебя таки за задача? Обычно С++ достаточно гибок, чтобы что-то придумать, просто не всегда лекарство лучше болезни

Скажем можно предложить такую мульку:

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 );
}

Здравствуйте, Lorenzo_LAMAS, Вы писали:

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

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

Нет, я все глупости найду и ткну — ребята, а вы случайно на работу принимая народ не тестируете? С такими знаниями, эх... жуть, куда страна катится!!!

 int *i=new int(0x33);

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

Здравствуйте, Erop, Вы писали:

А>>Да похоже что никак. Жаль. Придется потрахаться немного по больше.

E>А что у тебя таки за задача? Обычно С++ достаточно гибок, чтобы что-то придумать, просто не всегда лекарство лучше болезни

Спасибо , задача простая — но расказывать очень долго. Но главное, чтобы работа с массивом была быстрой. Изменение размера не нужно...

Поэтому вектора и прочий шит не подходит — медленно.

Здравствуйте, Аноним, Вы писали:

А>наслаждайтесь ...

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


А>

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

А>Это получилолсь из — >

А>

А>#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();
А>}
А>

1. А теперь откомпиль это в релизе с максимальной оптимизацией и запость опять.
2. В том же релизном коде замерь время выполнения функций fun1, fun2 и результаты опять давай нам.
3. выведи значения sizeof(iv), iv.capacity(), sizeof(i) (для int i[0x1000]) и результаты обратно в форум.

А>

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

А>Прекрасно работает.
А как это связано с инициализацией элементов массива, о чем и шла речь? Вы глупости и дурака лучше в зеркале поищите.