Форум программистов, компьютерный форум CyberForum.ru

STL Containers - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ STL Iterators http://www.cyberforum.ru/cpp-beginners/thread634421.html
Допустим есть проект #ifndef ContainerTemplateFunction_hpp // Preprocessor gates #define ContainerTemplateFunction_hpp #include <list> #include <vector> #include <iostream>
C++ Перевод из кодировки UTF - 8 в ANSI Всем привет! Пишу прогу на линухе, результаты работы вывожу в html файл. Так вот когда открываю файл для прочтения с помощью браузера там иероглифы, с помощью текстового редактора в linux то все ок. Я так понял что браузер не нравиться кодировка, конечно можно в настройках браузера изменить, но мне нужно что бы такой заморочки не было. Подскажите как мне изменить кодировку? http://www.cyberforum.ru/cpp-beginners/thread634420.html
C++ Книги для использования оконных приложений
Всем привет. Консольные приложение это хорошо, но я уже прочитал книгу, и более менее знаю азы c++. Но хотелось бы создавать уже нормальные, красивые приложения с использованием Windows Forms Application. Хочу попросить чтобы мне посоветовали литературу или сайт где есть уроки поповоду использования WFA.
C++ Разыменования указателя
Добрий день подскажите пожалуйса можно ли разыменовать такое вот виражения pt->str char*pt-указатель str объект класса _bstr_t нужно получить данные которые находятся в str если сделать вот так cout<< pt->str; то я данные вижу а если вот так SetDlgItemText(IDC_EDIT1,pt->str); то в окно EDIT1 ничего не выводит может его можно разыменовать?
C++ Засада с машинным эпсилон, или Либо я дурак http://www.cyberforum.ru/cpp-beginners/thread634398.html
Эту задачку выполняют все начинающие. Так вот, берём два простеньких кода. Они настолько коротки, тупы и очевидны, что я даже не комментировал их. Первый, работает нормально. #include <iostream> using std::cout; using std::endl;
C++ Тема: Записи. Работа с текстовыми файлами Тема: Записи. Работа с текстовыми файлами. Дан файл f, содержащий сведения о багаже нескольких пассажиров. Багаж пассажира характеризуется количеством вещей и общим весом вещей. Сведения о багаже каждого пассажира представляют собой запись с двумя полями: одно поле целого типа (количество вещей) и одно - действительное (вес в килограммах). Найти число пассажиров, имеющих более двух вещей и число... подробнее

Показать сообщение отдельно
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
10.08.2012, 15:04  [ТС]     STL Containers
Цитата Сообщение от ~OhMyGodSoLong~ Посмотреть сообщение
А то и значит: вам надо реализовать свой resize().

resize() изменяет размер вектора и в памяти, и доступный пользователю.
reserve() — только в памяти.

Смысл в том, что обычно это авторасширение делается так:
1. При создании вектора выделяется место, пусть, под 10 элементов. Это действительный размер вектора.
2. Эффективный размер всё ещё равен нулю.
3. Пользователь делает push_back() — эффективный размер растёт на единичку, элемент vector[0] становится доступным ему. Выделенная память при этом не изменяется.
4. Как вся предвыделенная память заполняется, вектор изменяет свой размер. На сколько именно — это эвристическая штука. Обычно увеличивается в полтора-два раза.
5. Обычно делаются ещё функция reserve(), которая позволяет зарезервировать заранее нужное место, чтобы не было перевыделений. Иногда ещё sqeeze(), для избавления от лишнего места: чтобы эффективный размер стал равен выделенному.

Вся соль в этом механизме: как эффективно увеличивать размер вектора. И как грамотно его уменьшать.

main
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
#include <iostream>
#include <list>
#include <vector>
#include <map>
#include <string>
 
 
 
void printlist(const std::list<double>& myList)
{
    std::list<double>::const_iterator i;
    for (i = myList.begin(); i != myList.end(); ++i)
        {
                std::cout << *i << "\n"; 
        }
}
 
int main()
    {
        
                std::cout       << "\n\t\t--- Level 7. Overview of the STL --- \n"
                                << "\t\t --- Exercise 1: STL Containers --- \n";
// _______________________________________________________ LIST __________________________________________________
                std::cout << 
"\n\n\t\t\t\t\t\t                     ____________________ LIST ____________________ ";
                std::cout   << "\n\n\t\t    --- TEST OF CONTAINER --- " 
                            << "\n\t\t\t  --- *LIST* --- \n " ;
 
        std::cout   << "\n Let's cast basic functionality of <list>" 
                    << "\n Container like how to include, exclude elements and ect "
                    << "\n First at all let's create data array that is filled doubles \n" ;
 
        const unsigned int size_of_data_array = 35; 
 
        double data_doubles[size_of_data_array] 
                    =  { 1830 , 190.1, 1914. , 1863 , 1839 ,        // 0 - 4
                         1413 , 1914 , 18.65 , 1656 , 18.95,        // 5 - 9
                         1455 , 1492 , 1517  , 1796 , 1610 ,        // 10 - 14
                         1882 , 1100 , 1776  , 1933 , 1117 ,        // 15 - 19
                         1876 , 1509 , 1945  , 1928 , 1859 ,        // 20 - 24
                         1903 , 172.2, 1.656 , 1088 , 1789 ,        // 25 - 29
                        1947. , 1211 , 196.9 , 1895 , 1628 } ;      // 30 - 34
 
/*
        std::cout   << "\n Now using push_back function fill"
                    << "\n Instance of list with elements from our the double array \n\n" ;
                
 
        std::list<double> TestListContainsDoubles ;     // List iterator
        for (int i = 0; i < 10; i++)
            {
                TestListContainsDoubles.push_back(data_doubles[i]);
            }
 
        std::cout   << "\n Using function printlist (that we create before) we can print the list \n";
 
        printlist(TestListContainsDoubles);
 
 
    
        std::cout   <<  "\n Using function front() we can return first element of the list." 
                    <<  "\n The first element of TestListContainsDoubles is :  " 
                    <<  TestListContainsDoubles.front() 
                    <<  "\n Using function back() we can return LAST element of list."
                    <<  "\n The LAST element of list1 is :  " 
                    <<  TestListContainsDoubles.back() ;
                
// _______________________________________________________ VECTOR ________________________________________________
std::cout << 
"\n\n\t\t\t\t\t\t                     ____________________ VECTOR ____________________ ";
    
            */      std::cout   << "\n\n\n\t\t     --- TEST OF CONTAINER --- " 
                                << "\n\t\t\t  --- *VECTOR* --- \n " ;
 
        std::cout   << "\n Let's cast basic functionality of <vertor> container " 
                    << "\n container like how to include, exclude elements and ect"
                    << "\n We will be use data array that we created before \n" ;
 
        std::cout   << "\n Now using push_back function fill"
                    << "\n Instance of <vector> with elements from our the double array \n\n" ;
 
        
 
        std::vector<double> VectorDoubles;
        for (unsigned int i = 0; i < size_of_data_array/5; i++)
            {
                VectorDoubles.push_back(data_doubles[i]);
            }   
        
            
        std::cout   << "\n Now let's  print our <vector> container  \n";
        
            for (unsigned int i = 0; i < VectorDoubles.size(); ++i)
                {
                    std::cout << "index ["<< i << "] element " << VectorDoubles[i] ;
                    if (i % 2 <= 0 )
                        std::cout << "\t\t"; 
                    else 
                        std::cout << "\n"; 
                }
 
            std::cout   << "\n --- Let's make out <vector > grow. ---  "
                        << "\n --- FIRST WAY --- "
                        << "\n For this purpose we can continue push_back new elements to the vector "
                        << "\n and the vector size we be increase automatically let's try this way and print again   ";
 
            std::cout   << "\n OLD Size of our <vector> is >  : " << VectorDoubles.size(); 
            std::cout   << "\n Let's push_back (add I mean ) new elements to the old ones";
            unsigned int old_size_vector = VectorDoubles.size();
            std::cout   << "\n ";
 
        for (unsigned int i = size_of_data_array/5; i < 2* old_size_vector; i++)
            {
                VectorDoubles.push_back(data_doubles[i]);
                
            }   
 
        std::cout   << "\n NEW size of our <vector> is   : " << VectorDoubles.size(); 
        std::cout   << "\n Let's print :  ";
        std::cout   << "\n ";
        for (unsigned int i = 0; i < VectorDoubles.size(); ++i)
                {
                    std::cout << "index ["<< i << "] element " << VectorDoubles[i] ;
                    if (i % 2 <= 0 )
                        std::cout << "\t\t"; 
                    else 
                        std::cout << "\n"; 
                }
 
            std::cout   << "\n --- SECOND WAY ---"
                        << "\n However, it is more efficient to call resize prior if you know how many elements. "
                        << "\n Otherwise push_back will keep resizing which is inefficient.";   
 
            std::cout   << "\n old size of the <vector> is   : " << VectorDoubles.size();
 
            old_size_vector = VectorDoubles.size(); // 14; 
            unsigned int new_size_vector = old_size_vector + 5; // 19; 
            std::cout << "\n adding new elements "; 
            
            for (unsigned int i = old_size_vector; i <= new_size_vector; i++)
            {
                VectorDoubles.resize(i,data_doubles[i] );
            //  VectorDoubles.push_back(data_doubles[i]);
            }   
 
            std::cout   << "\n NEW size of the <vector> is   : " << VectorDoubles.size(); 
            std::cout   << "\n Let's AGAIN print :  ";
            std::cout   << "\n ";
        for (unsigned int i = 0; i < VectorDoubles.size(); ++i)
                {
                    std::cout << "index ["<< i << "] element " << VectorDoubles[i] ;
                    if (i % 2 <= 0 )
                        std::cout << "\t\t"; 
                    else 
                        std::cout << "\n"; 
                }
 
 
            
            
 
        std::cout   << "\n Unlike <list> container "
                    << "\n Using <vector>  we can get access to any element "
                    << "\n of vector with which we work    " 
                    << "\n Just use operator [] (square braket)  \n\n";
                
                    unsigned int random_index  =  0; 
    
        unsigned int i = 0; 
        while (  i != VectorDoubles.size()-1)
            {
                    random_index = std::rand()%10;          // be carefull this rand generate from 0 to 10 so your container size will be greater then then 10 
                    std::cout   << "index ["<< random_index << "] element " 
                                << VectorDoubles[random_index];
 
                    if (i % 2 <= 0 )    std::cout << "\t"; 
                    else                std::cout << "\n";  
                i++;
            }
 
 
        /*
 
//  ______________________________________________________ MAP ______________________________________________________
        std::cout << 
"\n\n\t\t\t\t\t\t                     ____________________ MAP ____________________ ";
    
                        std::cout   << "\n\n\n\t\t     --- TEST OF CONTAINER --- " 
                                    << "\n\t\t\t  --- *MAP* --- " ;
 
        std::map<double, std::string> MapDoubleString;
        
 
        MapDoubleString[data_doubles[1]] = "one";
        MapDoubleString[data_doubles[2]] = "two";
        MapDoubleString[data_doubles[3]] = "three";
 
        for (auto i = MapDoubleString.cbegin(); i != MapDoubleString.cend(); ++i)
            {
                std::cout   <<"\n [" << i -> first <<"] - > <" << i -> second <<">" ;
            }
 
        std::cout   << "\n Unlike <list> or <vector> containers"
                    << "\n Using <map>  we can get access to any element or information"
                    << "\n Using key of a element"
                    << "\n Just use operator [] (square braket)"
                    << "\n For example let's get information that associate with key"
                    << "\n [data_doubles[1]] ( in other words  19.01 ) associate with - >  "
                    << MapDoubleString[data_doubles[1]] ; 
        */
        std::cout   << "\n\n\n\t\t"; 
        return 0;
    }

А резайзить в цикле это повышает производительность по сравнению с push_back ???

Добавлено через 1 минуту
Мой вопрос в следующем так кто нибудь делает или это очень странный вариант использование функции resize() ???
 
Текущее время: 12:59. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru