Собственно subj
Задача считать и распечатать структуру
1.txt
1234556909809.01.444443356784532

и т.д.

#include <fstream>
#include <iostream>
struct TEST
{
    char pole1[10];
    char pole2[10];
    char pole3;
    char pole4[9];
};
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
    TEST t;
    ifstream f("1.txt",ios::in);
    f.read((char*)&t,sizeof t);
    cout<< t.pole1 << endl;
    return 0;
}

у тебя с выравниванием проблема.

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

F>Собственно subj
F>Задача считать и распечатать структуру
F>1.txt
это название типо файла? или уже пошли данные "структуры"?

F>1234556909809.01.444443356784532

что собственно тут является полями структуры и какого оно формата?


F>и т.д.
F>

F>#include <fstream>
F>#include <iostream>
F>struct TEST
F>{
F>    char pole1[10];
F>    char pole2[10];
F>    char pole3;
F>    char pole4[9];
F>};
F>using namespace std;
F>int _tmain(int argc, _TCHAR* argv[])
F>{
F>    TEST t;
F>    ifstream f("1.txt",ios::in);
F>    f.read((char*)&t,sizeof t);
F>    cout<< t.pole1 << endl;
F>    return 0;
F>}
F>

УЖОС!!! нет слов...

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

1. Если используешь бинанрное чтение, то файл должен открываться соотвтетсвующим образом:

ifstream f("1.txt",ios::in | ios::binary);

3.Файл "1.txt" должен иметь соотвтетсвующую структуру, т.е. запись в него также должна быть произведена с помощью бинарной функции write.

3. В данном случае с выравниванием все нормально (sizeof(TEST) == sizeof(pole1) + sizeof(pole2) + sizeof(pole3) + sizeof(pole4)), но в общем случае об этом нужно позаботится. Т.е. нужно быть уверенным, что при записи и чтении бинарное представление структуры одно и то же.

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

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

B>1. Если используешь бинанрное чтение, то файл должен открываться соотвтетсвующим образом:
B>

B>ifstream f("1.txt",ios::in | ios::binary);
B>

B>3.Файл "1.txt" должен иметь соотвтетсвующую структуру, т.е. запись в него также должна быть произведена с помощью бинарной функции write.

B>3. В данном случае с выравниванием все нормально (sizeof(TEST) == sizeof(pole1) + sizeof(pole2) + sizeof(pole3) + sizeof(pole4)), но в общем случае об этом нужно позаботится. Т.е. нужно быть уверенным, что при записи и чтении бинарное представление структуры одно и то же.
Файл не мой т.е. я знаю только позиции полей и длину каждой записи. Он не двоичный а символьный

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

F>Собственно subj
F>Задача считать и распечатать структуру
F>1.txt
F>1234556909809.01.444443356784532


тут проблема в том, что во входных данных отсутствует \0 после окончания каждого поля структры

Здравствуйте, dcb-BanDos
если было хоть какое-нибудь разделение вопроса не было б есть только размер и набор
символьных строк

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

F>если было хоть какое-нибудь разделение вопроса не было б есть только размер и набор символьных строк
Строк в "общечеловеческом" понимании, но не в сишном.

Тебе что, сложно превратить массив символов в строку? Ай, как нефиг делать!

// 1234556909809.01.444443356784532
// \___________/ \/ \_____________/
//       a       b         c
#pragma pack(push,1)
struct FileRecord // только для чтения-записи в файл
{
    char a[13], dummy1, b[2], dummy2, c[15];
};
#pragma pack(pop)

// немножко по мотивам буста
template<class T, int N> T* begin(T(&arr)[N]) { return arr+0; }
template<class T, int N> T* end  (T(&arr)[N]) { return arr+N; }

template<class I, class J, class T> void copy_and_fill(I i, I ie, J j, J je, T v)
{
    for( ; i!=ie && j!=je; ++i, ++j)
        *je = *ie;
    for( ; j!=je; ++j)
        *j = v;
}

struct Record // для работы
{
    std::string a, b, c;
    
    Record(const FileRecord& src)
        : a(begin(src.a), end(src.a))
        , b(begin(src.b), end(src.b))
        , c(begin(src.c), end(src.c))
    {}
    
    void export(FileRecord& dst) const
    {
        copy_and_fill(a.begin(), a.end(), begin(dst.a), end(dst.a), ' ');
        dst.dummy1 = '.';
        copy_and_fill(b.begin(), b.end(), begin(dst.b), end(dst.b), ' ');
        dst.dummy2 = '.';
        copy_and_fill(c.begin(), c.end(), begin(dst.c), end(dst.c), ' ');
    }
};
inline std::ostream& operator << (std::ostream& ost, Record const& rec)
{
    ost << "{ ";
    ost << "\"" << rec.a << "\"" << ", ";
    ost << "\"" << rec.b << "\"" << ", ";
    ost << "\"" << rec.c << "\"";
    ost << " }";
    return ost;
}

Здравствуйте, Кодт, Вы писали КОД

Спасибо Всегда внимательно слежу и впитываю хороший стиль написания

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

F>Здравствуйте, dcb-BanDos
F>если было хоть какое-нибудь разделение вопроса не было б есть только размер и набор
F>символьных строк

все равно проблемы не понимаю, приведи, что должно быть в структуре на выходе при данном наборе входных данных

Здравствуйте, dcb-BanDos

на выходе должно быть заполненая структура причём считать её надо быстро и красиво
ну и типа cout << t.pole1 << endl;
я могу конечно и strncpy но хотелось покрасивше

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

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

F>>если было хоть какое-нибудь разделение вопроса не было б есть только размер и набор символьных строк
К>Строк в "общечеловеческом" понимании, но не в сишном.

К>Тебе что, сложно превратить массив символов в строку? Ай, как нефиг делать!
К>

К>// 1234556909809.01.444443356784532
К>// \___________/ \/ \_____________/
К>//       a       b         c
К>#pragma pack(push,1)
К>struct FileRecord // только для чтения-записи в файл
К>{
К>    char a[13], dummy1, b[2], dummy2, c[15];
К>};
К>#pragma pack(pop)

К>// немножко по мотивам буста
К>template<class T, int N> T* begin(T(&arr)[N]) { return arr+0; }
К>template<class T, int N> T* end  (T(&arr)[N]) { return arr+N; }

К>template<class I, class J, class T> void copy_and_fill(I i, I ie, J j, J je, T v)
К>{
К>    for( ; i!=ie && j!=je; ++i, ++j)
К>        *je = *ie;
К>    for( ; j!=je; ++j)
К>        *j = v;
К>}

К>struct Record // для работы
К>{
К>    std::string a, b, c;
    
К>    Record(const FileRecord& src)
К>        : a(begin(src.a), end(src.a))
К>        , b(begin(src.b), end(src.b))
К>        , c(begin(src.c), end(src.c))
К>    {}
    
К>    void export(FileRecord& dst) const
К>    {
К>        copy_and_fill(a.begin(), a.end(), begin(dst.a), end(dst.a), ' ');
К>        dst.dummy1 = '.';
К>        copy_and_fill(b.begin(), b.end(), begin(dst.b), end(dst.b), ' ');
К>        dst.dummy2 = '.';
К>        copy_and_fill(c.begin(), c.end(), begin(dst.c), end(dst.c), ' ');
К>    }
К>};
К>inline std::ostream& operator << (std::ostream& ost, Record const& rec)
К>{
К>    ost << "{ ";
К>    ost << "\"" << rec.a << "\"" << ", ";
К>    ost << "\"" << rec.b << "\"" << ", ";
К>    ost << "\"" << rec.c << "\"";
К>    ost << " }";
К>    return ost;
К>}
К>

красиво а по быстродействию быстрее чем strncpy
и как применить всё это

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

F>красиво а по быстродействию быстрее чем strncpy

Нет, это медленнее — хотя бы потому, что string использует динамическую память.
Но это надёжнее, очевиднее и более гибко.

А так — пожалуйста, можно написать функции по мотивам strncpy.

// условие: countof(dst) >= count+1
// результат: dst оканчивается нулём
void strncpy_z(char* dst, const char* src, size_t count)
{
    for( ; count && *src; ++src, ++dst, --count )
        *dst = *src;
    *dst = 0;
}

// условие: countof(dst) >= count; src оканчивается нулём
// результат: хвост dst забит указанными символами
void strncpy_c(char* dst, const char* src, size_t count, char pad)
{
    for( ; count && *src; ++src, ++dst, --count )
        *dst = *src;
    for( ; count; ++dst, --count )
        *dst = pad;
}

F>и как применить всё это

Так вы что, и конфеты за меня есть будете? — Ага!

ifstream file("1.txt", ios::in|ios::binary);

FileRecord fr; file.read(&fr, sizeof(fr));
cout << Record(fr) << endl;

Здравствуйте, Кодт
Спасибо!
насчёт последнего "как это применить" это
не закончил фразу привожу полностью
и как это применить если файл содержит
несколько строк(человеческих) ~150000 фиксированной длинннны
причём строки типа 1 может следовать только за строкой 0 ну и т.д.
Я сейчас тупо считываю построчно switch по типу,делаю класс и создаю коллекцию
из которой потом выбираю данные по строкам типа 0 и распечатываю
в заказанном виде
всё работает
но как-то хочется поинтересней вот и захотел через структуры что нить
оптимизировать

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

F>и как это применить если файл содержит
F>несколько строк(человеческих) ~150000 фиксированной длинннны
F>причём строки типа 1 может следовать только за строкой 0 ну и т.д.

F>Я сейчас тупо считываю построчно switch по типу,делаю класс и создаю коллекцию
F>из которой потом выбираю данные по строкам типа 0 и распечатываю в заказанном виде
F>всё работает
F>но как-то хочется поинтересней вот и захотел через структуры что нить оптимизировать

Не очень я понял, в чём состоит задача.
Верно ли то, что у тебя есть полиморфная коллекция (с разнотипными элементами — тип выбирается при считывании очередной строки),
и ты фильтруешь эту коллекцию, распечатывая только заданный тип?

Мне кажется, что считывать весь файл целиком — только ради этой задачи — смысла нет.
Прочитал очередную строку, проанализировал, при желании распечатал. Перешёл к следующей строке файла.
Максимум что потребуется, это машина состояний (конечный автомат).
Никакой коллекции и практически никакого полиморфизма.

Здесь есть аналогия с SAX- и DOM-парсерами. Зачем делать DOM, если SAX-а достаточно.

Ну а что касается структур... Конечно, считывать запись фиксированной ширины прямо в POD-структуру удобнее, чем каждое поле по отдельности, либо в символьный буфер с последующим его расковыриванием.

Здравствуйте, Кодт
Суть в том что имеется файл со строками фиксированной длины
строка с лидирующим 0 определяет количество и общие параметры для
строк с лидирующей 1 строки с лидирующими 2 — контрольные.
распечатывается типа

строка 0 (по особому виду)
строка 1 (формат своебразный)
строка 1 (формат своебразный)
.......
строка 1 (формат своебразный)
строка 2 (формат своебразный)


в строках есть признаки по которым в дальнейшем и происходит отбор
т.е. 0 строки нужны не все
поэтому я делаю так (схематично)

struct type0
{
   char pole1;
   char pole2[8];
   char pole3;
   char pole4[15];
   char pole2[2];
};

struct type1
{
   char pole1;
   char pole2;
   char pole3;
   char pole4[15];
   char pole2[2];
};
struct type2
{
   char pole1;
   char pole2[7];
   char pole3;
   char pole4[5];
   char pole2[2];
};

class A
{
   public:
     struct type0;
     struct type2;
     vector<type1> types1;
     и т.д.
     static vector<A> GetClassAFromFile();
}

вот так просто и неинтересно

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

F>вот так просто и неинтересно
Ну, казалось бы, и всё нормально.
Разве что хранить в программе можно не низкоуровневые записи (считанные из файла как есть), а уже разобранные и подготовленные к дальнейшей работе. В частности, чтобы строки там были уже с нулями.

По-прежнему вызывает вопрос: а нужно ли считывать весь файл целиком в структуру vector<ClassA> ? Или всё-таки можно построчно обрабатывать.

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

К>По-прежнему вызывает вопрос: а нужно ли считывать весь файл целиком в структуру vector<ClassA> ? Или всё-таки можно построчно обрабатывать.

ну в принцыпе согласен можно и сразу по по критериям в 0 строке
отбирать только нужные это да спасибо
запарился на одно и совсем упустил из виду
ну и файл может быть не один чего в дире то и скушать
по критерия в настроечном файле
вот так
большое спасибо очень познавательно получилось