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

Проклятые потоки. - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 9, средняя оценка - 4.89
CEBEP
105 / 105 / 9
Регистрация: 21.03.2010
Сообщений: 437
16.10.2011, 08:59     Проклятые потоки. #1
Нахрена? я изучал и читал и не нашел плюсов. смотрите:
Я создал поток, подключил в него буфером строку для парсинга:
Код
    -1
   151
Scan3.svd

PSV Version 8.7.2.2
06-Oct-11 18:00:49  
None      None      
PolyUFFExport 2.0.1.0 - Compatible to LMS
10-Oct-11 18:56:20 
    -1
" -1" - строка которой начинается и заканчивается блок, 151 - константа определяющая тип блока. Мне надо считать строки 3, 5, 6, 8 и 9 в соответствующие std::string. И ещё сделать проверочку. Пускай, самую грубую. Скажем, проверить, начинается ли мой блок с -1 и известен ли мне тип 151.
-1 как число интерпретировать нельзя, так как стандарт файла предусматривает ранение целых чисел в текстовом виде и -1 может оказаться по причинам не связанным с пометкой начала блока. Следовательно, я обязан проверить всю строку. т. е.
C++
1
2
std::getline(stream, buf);
if(buf != std::string("    -1")) { /*Генерация ошибки*/ }
Но, в буфере не содержится строка равная " -1", там содержится она же но с ещё одним символом в конце. Символ имеет числовой эквивалент 13 и не является '\n', что ещё можно было бы понять. Т. е. в конструктор я строку равную получаемой передать не могу. Так же, не могу оптимизировать сравнение приготовив
C++
1
const static std::string rightBlockSign("    -1");
так как я и инициализировать строку тоже не могу нормально. Изуверства типа
C++
1
2
static std::string rightBlockSign("    -1 ");
rightBlockSign[6] = 13;
тоже не помогают.
Думаете это конец бредятины? Ошибаетесь. Дальше больше:
Пуд соли съеден каждым хомячком желающим считать строку до '\n' а не до первого пробела/табуляции/символа новой строки. Мой блок имеет пустую четвёртую строку. Мне её надо пропустить а следующую считать в переменную PSVVersion. Как? std::getline() не передвинит бегунок если строка пуста. >> считает следующее слово, то есть "PSV", и курсор опять окажется не там где надо.
Друзья мои, я на грани того чтобы вернутся в девяностые и писать всё в стиле char*, помогите, объясните как выйти из ситуации!
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
16.10.2011, 08:59     Проклятые потоки.
Посмотрите здесь:

Потоки C++
потоки.. C++
потоки C++
Потоки C++
потоки C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
kravam
быдлокодер
 Аватар для kravam
1512 / 872 / 44
Регистрация: 04.06.2008
Сообщений: 5,271
16.10.2011, 11:49     Проклятые потоки. #21
Конечно пиши. Мне тоже интересно посмотреть на компактный код открытия файла в бинарном режиме при условии корректного считывания из него текстовых данных...
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
talis
 Аватар для talis
789 / 541 / 37
Регистрация: 11.05.2010
Сообщений: 1,298
Записей в блоге: 1
16.10.2011, 12:07     Проклятые потоки. #22
CEBEP, читайте в текстовом режиме:

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
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
 
#include <conio.h>
#include <stdlib.h>
 
#include <ctime>
 
// раскомментировать для вывода хода разбора
// #define DEBUG_OUT
 
enum EState
{
    BLOCK_BEGIN, BLOCK_BODY, BLOCK_BODY_SKIP, BLOCK_OUT,
    BLOCK_STATE_COUNT
};
 
int main()
{
    std::fstream fs( "Scan.unv" );
 
    if( !fs.is_open() )
    {
        std::cerr << "Could not open Scan.unv\n";
        return -1;
    }
 
    EState state = BLOCK_OUT; // состояние парсинга - вне блока
    int block_id; // id текущего блока
    unsigned str_count = 1; // номер строки
    unsigned block_str_count = 1; // номер строки в текущем блоке
 
    std::vector <std::string> data; // сюда будет парситься блок с id == 151
    std::string input; // сюда будет попадать ввод из файла
 
    clock_t parse_start = clock();
 
    for(;std::getline( fs, input );) // пока не достигли конца файла
    {
        #ifdef DEBUG_OUT
        std::cout << '\"' << input << '\"';
        #endif
 
        // если встречена строка -1 в начале или конце блока
        if( (state == BLOCK_OUT || state == BLOCK_BODY || state == BLOCK_BODY_SKIP) && input == "    -1" )
        {
           #ifdef DEBUG_OUT
           std::cout << " - block marker";
           #endif
 
           if( state == BLOCK_OUT ) // если мы вне блока
           {
               #ifdef DEBUG_OUT
               std::cout << " - waiting for block_id";
               #endif
 
               state = BLOCK_BEGIN; // мы в начале блока и ожидаем id блока
               block_str_count = 1; // это первая строка в этом блоке
           }
           else if( state == BLOCK_BODY || state == BLOCK_BODY_SKIP ) // если мы в конце блока
           {
               #ifdef DEBUG_OUT
               std::cout << " - block has ended";
               #endif
 
               state = BLOCK_OUT; // мы вне блока
               block_str_count = 0;
           }
        }
        else if( state == BLOCK_BEGIN ) // если мы в начале блока и ожидаем id блока
        {
            block_id = atoi( input.c_str() ); // читаем id блока
 
            #ifdef DEBUG_OUT
            std::cout << " - block ID (" << block_id << ')';
            #endif
 
            if( block_id == 151 ) // если это наш id
            {
                #ifdef DEBUG_OUT
                std::cout << " - reading";
                #endif
 
                state = BLOCK_BODY; // парсим блок
            }
            else
            {
                #ifdef DEBUG_OUT
                std::cout << " - skipping";
                #endif
 
                state = BLOCK_BODY_SKIP; // иначе пропускаем блок
            }
        }
        else if( state == BLOCK_BODY ) // если мы парсим блок
        {
            #ifdef DEBUG_OUT
            std::cout << " - parsing block " << block_id << " (str " << block_str_count << ')';
            #endif
 
            if( block_id == 151 ) // если это блок 151
            {
                switch( block_str_count )
                {
                    case 3: case 5: case 6: case 8: case 9:
                    data.push_back( input ); // если это нужная нам строка, заносим её в список строк
                    break;
                }
            }
        }
        else if( state == BLOCK_BODY_SKIP ) // если мы пропускаем блок
        {
            #ifdef DEBUG_OUT
            std::cout << " - skipping block " << block_id << " (str " << block_str_count << ')';
            #endif
        }
 
        #ifdef DEBUG_OUT
        std::cout << '\n';
        system( "pause > nul" );
        #endif
 
        str_count++;
        block_str_count++;
    }
 
    fs.close();
 
    clock_t parse_end = clock();
 
    std::cout << "EOF reached in " << parse_end - parse_start << " ms.\n" << str_count << " strings read\n\nData:\n\n";
 
    for( int i = 0; i < data.size(); i++ )
        std::cout << '\"' << data[i] << "\"\n";
 
    std::cout << "--------------------\nTotal: " << data.size() << " strings\n\nGoodbye!\n";
 
    return 0;
}
У меня отработала за 110 мс.

AMD Turion 2.20 GHz, 3GB RAM; gcc без оптимизаций.
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
16.10.2011, 20:28     Проклятые потоки.
Еще ссылки по теме:

Потоки C++
Потоки C++
C++ Проклятые функции

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
CEBEP
105 / 105 / 9
Регистрация: 21.03.2010
Сообщений: 437
16.10.2011, 20:28  [ТС]     Проклятые потоки. #23
Действительно, используя строковый стрим только потерял половину секунды. Вообще, разбор занимает 5.5 секунд примерно. Завтра напишу разбор в стиле си, посмотрю на сколько он будет быстрее...
main.cpp:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "UNVData.h"
#include<iostream>
#include<string>
#include<ctime>
 
int main()
{
    std::clock_t tStart = std::clock();
 
    UNVData unv("C:\\Users\\CEBEP\\Desktop\\Scan.unv");
 
    std::cout << "Delta time = " << static_cast<double>(std::clock() - tStart) / CLOCKS_PER_SEC << std::endl;
 
    std::cin.get();//5.5 секунд
}
UNVData.h:
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
214
215
216
217
218
219
220
221
222
#pragma once
#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <sstream>
 
class UNVData
{
/*
Описывает структуру типичного заголовка типа
 
 
 
//Всегда -1
*/
    const static std::string rightCurrentRow;
            /*
//Число. Принемает следующие значения: 151, 164, 2411, 82, 58. В соответствии с числом дальнейший вид меняется соответственно и тоже 5 раз.
 
//Для 151:
Scan3.svd//Имя файла из которого сделан экспорт
 
PSV Version 8.7.2.2//Версия станка
06-Oct-11 18:00:49  //Когда проведён эксперемент
None      None      //Чушь
PolyUFFExport 2.0.1.0 - Compatible to LMS//Какой-то выпендрёж
10-Oct-11 18:56:20 //Время, когда был сделан экспорт
    -1//Далее и везде - "\n    -1" - признак конца структуры и начала новой.
//И ничего вовсе. далее остальной файл.
//Для 164:
         1METRIC_ABS_(SI)              2//гуглит для такой строки другие unv, для них три константы ниже тоде единицы, четвёртая другая.
  1.00000000000000000E+00  1.00000000000000000E+00  1.00000000000000000E+00
  0.00000000000000000E+00//Имено это число меняется, ито не обязательно
    -1
//Так же объёмной части не содержит.
//Для 2411: Не имеет не заголовка не признака его отсутствия(NONE), сразу выводит массив вида
%10d%10d%10d%10d\n%25lf%25lf%25lf//4 целых по 10 символов под число, переход на строку и ещё 3 двойных по 25 
//символов на число, -1
//Для 82: Не имеет заголовка не признака его отсутствия(NONE), сразу выводит структуру формата:
"%10d%10d%10d\n\
NONE\n\
%10d%10d%10d%10d%10d\n"//Т. е. 3 целых, NONE, 5 целых
         1         5         7
NONE
        17        25        27        17         0
    -1
//Для 58:
Reference Linear Spectrum//Хрень для важности
Ref1  Voltage//что в массиве
06-Oct-11 18:00:49  //Опять дата. видимо на случай очень медленного конструирования файла.
Scan3.svd//Ну ты понел.
NONE//Тоже не меняется
   12         3    1         0       NONE         9   1       NONE         1   3//Меняются числа соответствующие 9 и 1
         2       800         1  6.25000e-01  6.25000e-01  0.00000e+00//меняющееся целое, далее одинаково
        18    0    0    0            Frequency                   Hz//Меняется первое число и строковые значения.
         0    0    0    0              Voltage                    V//Так же  первое число и строковые значения.
         0    0    0    0                 NONE                 NONE//Не меняется
         0    0    0    0                 NONE                 NONE//То же
//далее большой массив из %13lf
//Определяю заголовку следующий формат: 
"%5d     %5d%5d     %5d       NONE      %4d%4d       NONE      %4d%4d\n\
%10d%10d%10d%13f%13f%13f\n\
     %5d%5d%5d%5d%21s%21s\n\
     %5d%5d%5d%5d%21s%21s\n\
     %5d%5d%5d%5d%21s%21s\n\
     %5d%5d%5d%5d%21s%21s\n\
while(!-1)%13f%13f%13f%13f%13f\n"
        
        
 
Итог: в данном файле есть 5 типов структур, каждая ограничина строками "    -1" сверху и снизу,
далее следует строка с номером типа далее содержимое
 
 
Требуемые функции:
Считывание целого в зоне от 4 до 10 символов с заполнением пробелами
Аналогичное чтение вещественных в 25 и 13 символов (кстате, намекает на float и double чуть 
    менее чем наверняка). Хорошо,если по n сразу
Чтение строки до символа перехода на новую строку, и в 21 символ с заполнением пробелами.
 
        */
    float  numFloat (char* position);//Для случая в 13 символов
    double numDouble(char* position);//Для случая в 25 символов
    int    numInt   (char* position);//Для случая в 4 символа
 
    std::string stringLim(char* position, unsigned length);
    std::string stringStr(char* position);
 
/*
Хранимые структуры:
Так как я не смог найти документации по unv,претендовать на универсальность безсмысленно. В этой связи
Формат 151 равносилен ini информации, разбирается в конструкторе и хранится в константах класса.
*/
    std::string sourseFile,
                PSVVersion,
                experementDate,
                exprotProgram,
                exportDate;
    /*
Формат 164 проверяется на соответствие строке однообразия. Выдаётся предупреждение с просьбой сообщить 
    мне на [email]vornon@ya.ru[/email] о случившемся.
Формат 2411 реализован как вектор из трёх double ибо целые бредовые какие-то. Первое - id, остальные одинаковые.
*/
    std::vector< std::vector<double> > geometry;//Есть мнение, что это геометрия - количество элементов = колличеству точек сканирования!
    /*
Формат 82 реализован как массив из 8 целых. Этот формат встречается много раз. Все экземпляры хранятся в векторе.
*/
    std::vector< std::vector<int> > elements82format;//Длинна его, по всей видимости, совпадает с длинной vainVector...
    /*
Формат 58 - отдельный класс.
*/
    struct ScanData
    {
        /*
    Формат 58 - отдельный класс. Cтроковую информацию не хранит. Проверяет формат на соответствие определённом, выдаёт
        предупреждение с просьбой. Строку 2 (Vib X  Velocity), слова строк 8 и 9 хранит в виде перечислений 3 типов 
        (для 8 и 9 общий на 2 слова по столбцам.) 
    */
        enum Type    { VibXVelocity, VibYVelocity, VibZVelocity };
        Type type;
        enum Measure { Hz, m_s };
        Measure measure;
        enum Value   { Frequency, Velocity };
        Value value;
        /*
        Строки 6 - 9 хранит в матрице целых, 10 и 11 не хранятся
    */
        std::vector<int> numbers6_9;
        /*float для 7 строки хранит в
        массиве из 3 чисел,
    */
        std::vector<double> floatNumbers;
        /*double Для > 11 строк хранит в векторе. Его длинна вычисляется при считывании, приниается конструктором.
    */
        std::vector<double> mainArray;
        
        ScanData(std::ifstream& file):
            floatNumbers(3),
            numbers6_9(19)
        {
            floatNumbers.resize(3);
            numbers6_9.resize(19);
            mainArray.reserve(100);
            std::string currentRow;
            file.get();
            std::getline(file, currentRow);
            std::getline(file, currentRow);
            if(currentRow == std::string("Vib X  Velocity"))
                type = VibXVelocity;
            else if(currentRow == std::string("Vib Y  Velocity"))
                type = VibYVelocity;
            else if(currentRow == std::string("Vib Z  Velocity"))
                type = VibZVelocity;
            else
                ;//std::cout << currentRow << std::endl;
            
            file.get();
            std::getline(file, currentRow);
            std::getline(file, currentRow);
            std::getline(file, currentRow);
 
            file >> numbers6_9[0] >> numbers6_9[1] >> numbers6_9[2] >> numbers6_9[3];
            file >> currentRow >> numbers6_9[4] >> numbers6_9[5] >> currentRow
                 >> numbers6_9[6] >> numbers6_9[7] >> numbers6_9[8] >> numbers6_9[9] 
                 >> numbers6_9[10] >> floatNumbers[0] >> floatNumbers[1] >> floatNumbers[2]
                 >> numbers6_9[11] >> numbers6_9[12] >> numbers6_9[13] >> numbers6_9[14]
                 >> currentRow;
            if(currentRow == std::string("Freauency"))
                value = Frequency;
            if(currentRow == std::string("Velocity"))
                value = Velocity;
            else
                ;//std::cout << currentRow << std::endl;
            file >> currentRow;
            if(currentRow == std::string("Hz"))
                measure = Hz;
            if(currentRow == std::string("m/s"))
                measure = m_s;
            else
                ;//std::cout << currentRow << std::endl;
 
            file >> numbers6_9[15] >> numbers6_9[16] >> numbers6_9[17] >> numbers6_9[18]
                 >> currentRow;
            if(currentRow == std::string("Freauency"))
                value = Frequency;
            if(currentRow == std::string("Velocity"))
                value = Velocity;
            else
                ;//std::cout << currentRow << std::endl;
            file >> currentRow;
            if(currentRow == std::string("Hz"))
                measure = Hz;
            if(currentRow == std::string("m/s"))
                measure = m_s;
            else
                ;//std::cout << currentRow << std::endl;
            file.get();
            std::getline(file, currentRow);
            std::getline(file, currentRow);
            double cnt;
            do
            {
                file >> cnt;
                mainArray.push_back(cnt);
            }
            while(cnt != -1);
            file.get();
        }
        ~ScanData(void)
        {
        }
    };
    std::vector<ScanData> mainVector;
    
    UNVData(void);
    UNVData(const UNVData&);
    void compleetBlockTest(std::ifstream,int);
public:
    UNVData(std::string file);
    ~UNVData(void);
};
UNVData.cpp
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
#include "UNVData.h"
 
const std::string UNVData::rightCurrentRow("    -1");
 
UNVData::UNVData(std::string fileAdr)
{
    std::ifstream file(fileAdr);
 
    if(!file)
    {
        std::cerr << "Can't open file \"" << fileAdr << "\" licke binary!";
    }
    else
    {
 
        int blockType;
        std::string buf;
        const static std::string block164("         1METRIC_ABS_(SI)              2  1.00000000000000000E+00  1.00000000000000000E+00  1.00000000000000000E+00  0.00000000000000000E+00");
        std::string currentRow;
        std::string bufer;
        
        elements82format.reserve(50);
        int elements82counter = 0;
 
        while (std::getline(file, currentRow))
        {
            if(currentRow != rightCurrentRow)
            {
                std::clog << "Found information outside of the block." << currentRow << std::endl;
                do
                {
                    std::getline(file, currentRow);
                    std::clog << currentRow << std::endl;
                std::cin.get();
                }
                while(currentRow != rightCurrentRow);
            }
 
            file >> blockType;
            switch(blockType)
            {
            case 151:
                file.get();
                std::getline(file, sourseFile);
                file.get();
                std::getline(file, PSVVersion);
                std::getline(file, experementDate);
                std::getline(file, exprotProgram);//Просто, чтобы проскочить строку. Ну а как ещё?
                std::getline(file, exprotProgram);
                std::getline(file, exportDate);
                std::getline(file, currentRow);
 
                if(currentRow != rightCurrentRow)
                {
                    std::clog << "Block " << blockType << " contain mistake.\nInformation:\n\tSourse file:\t"
                        << sourseFile << "\n\tExperement date:\t" << experementDate << "\n\tPSV Version:\t"
                        << PSVVersion << "\n\tExprot program:\t" << exprotProgram << "\n\tExport date:\t"
                        << exportDate << "\nUnsuporting information:\n";
                    while(currentRow != rightCurrentRow)
                    {
                        std::clog << currentRow << std::endl;
                        std::getline(file, currentRow);
                    }
                }
                break;
            case 164:
                file.get();
                std::getline(file, buf);
                std::getline(file, currentRow);
                buf += currentRow;
                std::getline(file, currentRow);
                buf += currentRow;
                if(block164 != buf)
                    std::clog << "Block 164 does not match the expected format. Notify me [email]vornon@ya.ru[/email]!\n";
                
                std::getline(file, currentRow);
                if(currentRow != rightCurrentRow)
                {
                    std::clog << "Block " << blockType << " contain mistake. Unsuporting information:\n";
                    while(currentRow != rightCurrentRow)
                    {
                        std::clog << currentRow << std::endl;
                        std::getline(file, currentRow);
                    }
                }
                break;
            case 2411:
                geometry.reserve(10);//Едва ли кто-то проведёт эксперемент с меньшим колличеством точек
                int i;
                i = 0;
                file.get();
                std::getline(file, currentRow);
                while(currentRow != rightCurrentRow)
                {
                    geometry.push_back(std::vector<double>(3));
                    file >> geometry[i][0] >> geometry[i][1] >> geometry[i][2];
                    ++i;
                    file.get();
                    std::getline(file, currentRow);
                    geometry.push_back(std::vector<double>(3));
                }
                break;
            case 82:
                elements82format.push_back(std::vector<int>(8));
                {//Инициализация внутри case возможна только если заключена в {}
                    std::vector<int>& currentVector = elements82format[elements82counter];
                    file >> currentVector[0] >> currentVector[1] >> currentVector[2];
                    file.get();
                    std::getline(file, currentRow);
                    file >> currentVector[3] >> currentVector[4] >> currentVector[5] 
                    >> currentVector[6] >> currentVector[7];
                }
                ++elements82counter;
                file.get();
                std::getline(file, currentRow);
                if(currentRow != rightCurrentRow)
                {
                    std::clog << "Block " << blockType << " contain mistake. Unsuporting information:\n";
                    while(currentRow != rightCurrentRow)
                    {
                        std::clog << currentRow << std::endl;
                        std::getline(file, currentRow);
                    }
                }
                break;
            case 58:
                mainVector.push_back(ScanData(file));
                break;
            default:
                std::clog << "Block " << blockType << " is unknown. Information loosed." << std::endl;
                do
                {
                    std::getline(file, currentRow);
                }
                while(currentRow != rightCurrentRow);
                std::cin.get();
            }
        }
    }
}
void UNVData::compleetBlockTest(std::ifstream stream, int blockType)
{
    std::string currentRow;
    stream.get();
    std::getline(stream, currentRow);
    if(currentRow != rightCurrentRow)
    {
        std::clog << "Block " << blockType << " contain mistake. Unsuporting information:\n";
        while(currentRow != rightCurrentRow)
        {
            std::clog << currentRow << std::endl;
            std::getline(stream, currentRow);
        }
    }
}
 
UNVData::~UNVData(void)
{
}
Думаю, тут можно оптимизировать примерно вдвое если получше разобраться в потоках, но суть, скорее всего, не изменится - Разбор весьма не быстр.
Yandex
Объявления
16.10.2011, 20:28     Проклятые потоки.
Ответ Создать тему
Опции темы

Текущее время: 05:29. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru