Люди посоветуйти как лутчи произвести ввод/вывод массива структур в файл и из файла?
Зарание спасабо!!!

Что то вроде этого.

Код

#include <stdio.h> typedef struct {   int a;   char k;   double v; } my_struct;       void write_to_file(const char *pFileName, my_struct* slist, int nSize) {   FILE *fp = fopen( "structs.dat", "w" );   fwrite( slist, nSize, sizeof( my_struct ), fp );   fclose( fp ); } void read_from_file( const char *pFileName, my_struct* slist, int nSize ) {   FILE *fp = fopen( "structs.dat", "r" );   fread( slist, nSize, sizeof( my_struct ), fp );   fclose( fp ); } int main() {   my_struct slist[10];   write_to_file( "struct.dat", slist, 10 );   read_from_file( "struct.dat", sl, 10 );   return 0; }

если в структурах есть указатели, не так все просто.

Цитата

если в структурах есть указатели, не так все просто.

А кто говорил про указатели?

это на тот случай, если у автора есть в структурах указатели, но он их не упамянул.

Цитата

это на тот случай, если у автора есть в структурах указатели, но он их не упамянул.

В принципе если есть указатели тогда фиг так легко отделаешся...как минимум описание структуры должно быть...универсальную функцию для этого написать будет сложновато...я бы даже сказал очень сложновато...
Добавлено @ 12:37
Надо будет пройтись по структуре, выяснить где у нее находятся динамические переменные, а где статические...а потом еще проверить а может динамическая переменная не инициализирована? а вдруг она уже удалена и программа полетит к чертовой матери...

Это не на пару строк тема...
Добавлено @ 12:40
Пока не представляю как можно выяснить что из себя представляет кусок памяти размером в 4 байта, переменную типа int или указатель...но задача интересная, можно на ней подумать...

Цитата(azesmcar @ 28.9.2005, 16:35)

Пока не представляю как можно выяснить что из себя представляет кусок памяти размером в 4 байта, переменную типа int или указатель...но задача интересная, можно на ней подумать...

Не стоит. Элджер довольно не плохо обдумывал подобное в С++ Библиотеке программиста(оригназв "C++ for real programmers"). Что-либо утешительного Элджер не надумал.

Ну почему же? можно поизвращяться...

Передать функции write_struct_to_file массив описивающий структуру...например

Код

typedef struct {     int a;     double t;     char *k; } my_struct; my_struct obj; obj.a = 5; obj.t = 2.57; strcpy( obj.k, "Hello world!!!" ); int struct_description[3][2]; struct_description[0][0] = 4; //размер первого member-а struct_description[0][1] = 0; //тип первого member-а (0 - static, 1 - pointer) struct_description[1][0] = 8; //размер второго member-а struct_description[1][1] = 0; //тип второго member-а (0 - static, 1 - pointer) struct_description[2][0] = strlen( obj.k ) ; //размер третьего member-а struct_description[2][1] = 1; //тип третьего member-а (0 - static, 1 - pointer)

Но все равно НЕ ИНТЕРЕСНО

Если в структуре нет указателей, то самый оптимальный (в смысле скорости) способ записи массива (линейного контейнера) - бинарный, через потоки ввода вывода;

Код

template <class T> ostream& operator << (ostream& refStream, const vector <T>& refVector) throw ()     {         refStream.write (reinterpret_cast <const char*> (&refVector.front ()), refVector.size () * sizeof (T));         //-----------------------------------------------------         return refStream;     }

Но тут возникает проблема считывания данных из потока (перед считыванием необходимо знать сколько объектов собираешся считать).

Вообще низкоуровневый вывод/вывод в С++ это не то, что необходимо использовать, используй все преимущества потоков ввода вывода, например:

Определи в некотором базовом классе две функции: bool ToStream (std::ostream&) const и bool FromStream (const std::istream&);, или (что более красиво), одну перегруженную функцию:

Код

struct IObject {     virtual bool Serialize (std::ostream&) const     {         assert (! "IObject not have implementation for method bool Serialize (std::ostream&) const!");         //-----------------------------------------------------------     }     virtual bool Serialize (const std::istream&)     {         assert (! "IObject not have implementation for method bool Serialize (const std::istream&)!");         //-----------------------------------------------------------     }     virtual ~IObject ()     {         //-----------------------------------------------------------     } };

Потом отнаследуй свои структуры (объекты) от данного интерфейса и реализуй его:

Код

struct Figures : public IObject {     float    m_flFloat;     double    m_dbDouble;     int        m_iInt;     //-----------------------------------------------------------------------------------     explicit Figures (const float flFloat = float (), const double dbDouble = double (), const int iInt = int ()) : IObject (), m_flFloat (flFloat), m_dbDouble (dbDouble), m_iInt (iInt)     {         //-----------------------------------------------------------     }     //-----------------------------------------------------------------------------------     virtual bool Serialize (std::ostream& refOstream) const     {         refOstream << m_flFloat;         //-----------------------------------------------------------         refOstream << m_dbDouble;         //-----------------------------------------------------------         refOstream << m_iInt;         //-----------------------------------------------------------         return true;     }     virtual bool Serialize (const std::istream& refIstream)     {         refIstream >> m_flFloat;         //-----------------------------------------------------------         refIstream >> m_dbDouble;         //-----------------------------------------------------------         refIstream >> m_iInt;         //-----------------------------------------------------------         return true;     }     //----------------------------------------------------------------------------------- };

, после всего для "полной совместимости" с потоками ввода/вывода можно добавить пару новых функций (перегруженных операторов)

Код

std::ostream& operator << (std::ostream& refStream, const IObject& refObject) {     refObject.Serialize (refStream);     //---------------------------------------------------------------     return refStream; } const std::istream& operator >> (const std::istream& refStream, IObject& refObject) {     refObject.Serialize (refStream);     //---------------------------------------------------------------     return refStream; }

тебе необходимо положить линейный контейнер (массив) в поток (файл). Заполняем линейный контейнер:

Код

std::vector <Figures> vcFigures (5);                                    // в контейнере пять объектов (значения заданы конструктором по умолчанию) std::ofstream ofStream ("figures.txt");                                                                // файл для вывода std::copy (vcFigures.begin (), vcFigures.end (),      std::ostream_iterator <Figures> (ofStream, " "));                    // собственно запись в файл

При работе с объектами в С++ не используй низкоуровневый ввод/вывод - используй потоки ввода/вывода!
И забудь про массивы в С++, есть ведь линейные контейнеры!

Примечание: методы сериализации специально упрощены, необходимо добавить проверки свойства good () и.т.д.

Цитата(np9mi7 @ 30.9.2005, 00:00)

самый оптимальный (в смысле скорости) способ записи массива (линейного контейнера) - бинарный, через потоки ввода вывода

Функции работы с потоками достаточно медленны по выполнению (в сравнении с буферизированным вводом/выводом)

Цитата(np9mi7 @ 30.9.2005, 00:00)

И забудь про массивы в С++, есть ведь линейные контейнеры!

опять имеем дело с потерей производительности, простой массив работает гораздо быстрей


а вот идея с перегрузкой довольно неплоха (причем тут можно даже с указателями справиться)
получиться примерно так :

Код

typedef struct tagSerializableStruct {      virtual void Save(FILE *pFile) = 0;      virtual void Load(FILE *pFile) = 0; } SerialazableStruct; void LoadStructArray(FILE *pFile, SerializableStruct** pDest, int count) {     for(int i=0; i<count; i++)     {          pDest[i] = new NeedStructType;          pDest[i]->Load(pFile);     } } void SaveStructArray(FILE *pFile, SerializableStruct** pSrc, int count) {     for(int i=0; i<count; i++)     {          pDest[i]->Save(pFile);     } }

Правдо всеравно придеться определить все нужные типы структур так что это полу универсальность
В добавок можно еще перед самой структурой писать в файл ее тип (или по номеру или по имени) а при считывании проверять

Это сообщение отредактировал(а) Mad - 30.9.2005, 01:28

Цитата(np9mi7 @ 30.9.2005, 05:00)

refStream.write (reinterpret_cast <const char*> (&refVector.front ()), refVector.size () * sizeof (T));

юзать sizeof(t) не самая лучшая идея - выравнивание данных на диске нам не к чеме, ведь так? А эти #pragma... Ну вообщем имхо они не красивые.

Цитата(Mad @ 30.9.2005, 05:27)

опять имеем дело с потерей производительности, простой массив работает гораздо быстрей

Я тоже оптимизацию люблю
Хотя всё же vector достаточно быстр. Ну всё равно не так, как сишный. В с++ realloc нет

Цитата(Mad @ 30.9.2005, 05:27)

pDest[i] = new NeedStructType; pDest[i]->Load(pFile);

Тогда уж лучше pDest[i] = NeedStructType::load(pFile);
типа виртуальный конструктор.

Цитата(Mad @ 30.9.2005, 05:27)

В добавок можно еще перед самой структурой писать в файл ее тип (или по номеру или по имени) а при считывании проверять

Можно поиграться с хэшированием(хэш ф-ция определяется опытным путем).

Код

#define hashfn(str, salt) (str[0]+salt)+(str[1]?str[1]-salt +...тд  : 0) struct str{     enum hash = hashfn(__FILE__, __LINE__); };

не самый лучший вариант, но тоже вариант

Это сообщение отредактировал(а) Mayk - 30.9.2005, 07:19

Цитата

опять имеем дело с потерей производительности, простой массив работает гораздо быстрей

, в чем быстрее? Приведи пример.

Цитата

Функции работы с потоками достаточно медленны по выполнению (в сравнении с буферизированным вводом/выводом)

, немного тебя не понял. Приведи пример задачи на которой это реально можно ощутить...

np9mi7
По поводу масивов и контейнеров.
Векторы - это динамические массивы и они предназначены для оптимизации использования памяти
Статические массивы - оптимизация производительности
При работе с дин. массивами добавляються дополнительные операции с перераспредилением памяти.

По поводу потоков, если ты посмотриш исходный код с++ библиотек, то увидиш, что внутри реализация сделанна через буфурные функции IO, плюс куча кода

Цитата

По поводу масивов и контейнеров. Векторы - это динамические массивы и они предназначены для оптимизации использования памяти Статические массивы - оптимизация производительности При работе с дин. массивами добавляються дополнительные операции с перераспредилением памяти.

, Mad, это то понятно, ты пример приведи где это ощущается....????

Цитата(np9mi7 @ 30.9.2005, 15:15)

Mad, это то понятно, ты пример приведи где это ощущается....????

Надо полагать там, где быстродействие необходимо.
Взять хотя бы игрушки.

Mayk, человек утверждает, что:

Цитата

При работе с дин. массивами добавляються дополнительные операции с перераспредилением памяти.

, если ты её не перераспределяешь, то они не добавляются;

Самая частая операция применимая к массиву, это что? Правильно - взятие объекта по индексу:

Код

Figures arrFigures [5]; arrFigures [1];                // одно и тоже *(arrFigures + 1);            // одно и тоже

Смотрим реализацию этих операций в векторе:

Код

reference operator[](size_type __n) { return *(begin() + __n); } const_reference operator[](size_type __n) const { return *(begin() + __n); }

Где потеря произволительности?

Это сообщение отредактировал(а) np9mi7 - 30.9.2005, 12:47

Цитата

И забудь про массивы в С++, есть ведь линейные контейнеры!

Ну а ты вроде как утверждаешь что в С++ массивы вообще никому не нужны..всем пора бы про ниx и перейти на STL.. Ты неправ...

Привожу пример, ты решил написать шашки??? так что? чтобы хранить доску ты будешь хранить vector из STL??? есть случаи когда имеет смысл использовать STL а есть случаи когда совсем нет...

хотя бы не стоит использовать потому что ты включаешь в свой проект нехилую библиотеку шаблонных классов...как никак а это бессмысленно...и очень может быть на нашем пентиуме 4 никакой разницы ты даже не почувствуешь, а вот попиши как я годик на процессоре 8xx с тактовой частотой 70 мегагерц и винтом размером с мою оперативную память...сразу почувствуешь...убрав STL из проекта и переписав его на C я в 2 раза скорость работы увеличил...как тебе??? по моему чувствуется
Добавлено @ 14:53
Еще потеря производительности...при использовании массивов в С++ ты пишешь прямо в оперативную память, а в stl за тебя это делает функция...лишний call...еще 50000 таких лишних call-ов и программа начнет работать медленней на несколько секунд...

Зависит от задачи, но советовать забыть массивы С++ это слишком...

Цитата(Mad @ 30.9.2005, 09:50)

При работе с дин. массивами добавляються дополнительные операции с перераспредилением памяти.

Ну, в общем, не совсем это правда - если говорить о хорошей реализации, STL, например.
Если не надо расширять vector, то нет там никаких операций перераспределения памяти. А если надо - что, в C-шном массиве без malloc сможете обойтись? Только все своими ручками придется делать, ошибки плодить, потом отлаживать...
Конечно, теоретически какие-то доп. издержки вроде есть. Но по сравнению с каким-нибудь вызовом Windows API это такие крохи, что под микроскопом не разглядишь. Попробуйте смеха ради заменить где-нибудь в реальном коде массив на vector и посмотреть в профайлере. Не думаю, что увидете разницу раньше, чем на 333 месте по времени...

Цитата(azesmcar @ 30.9.2005, 14:50)

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

Ничего ты не включаешь, кроме того, что используешь.

Цитата(azesmcar @ 30.9.2005, 14:50)

при использовании массивов в С++ ты пишешь прямо в оперативную память, а в stl за тебя это делает функция...лишний call

там практически все inline - посмотри в профайлере .
В том-то и состоит великая мощь шаблонов вообще, и STL в частности, что за потрясающую гибкость ты почти не платишь. "Почти" - потому что увеличивается время компиляции, но и это можно победить с помощью прекомпилированных заголовков.

Цитата

Ничего ты не включаешь, кроме того, что используешь.

Ну да, а разве я что то другое сказал??? Что-то используешь...что то включаешь...ничего не используешь..ничего не включаешь..логично.

Цитата

там практически все inline - посмотри в профайлере .

Я бы не сказал что все...все что возможно инлайн...а возможно далеко не все...

Я же сказал что конкретно зависит от задачи, стл штука прекрасная, не спорю, но пихать его куда попало все же не стоит...как ни крути а все равно медленней чем с массивами С++...И если использовать СТЛ в конкретной задаче нет смысла то замедлять свою программу даже на какие то 0.000000001 милисекунду не имеет смысла...

azesmcar, учите мат часть и жизнь сразу станет хороша

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

В с++ нет realloc()а. Знаю, знаю, operator= и всё такое, но всегда ли оно надо?

А вообще, блин, нашли что сравнивать. vector и массив. не народ, вам что - делать нечего?

1) Использование STL ускоряет написание любых программ в разы.

2) Могу представить себе только одну ситуацию, когда нет смысла использовать вектор: если размер массива задан жестко-прежестко константой времени компиляции. И производительность здесь совершенно не при чем - просто в массив можно засунуть то, что в вектор не очень-то положишь - некопируемые smart-указатели, например. Или нужен статический (в смысле контекста) контейнер заданного размера - тогда тоже лучше массив - можно инициализировать списком.

Но и в этом случае я бы использовала алгоритмы STL для всяческих хождений по этому массиву - find, sort, for_each, etc, etc - ибо см. п 1)
Добавлено @ 16:33

Цитата(azesmcar @ 30.9.2005, 16:27)

практика все же показывает что я прав...

... просто ее мало...

Цитата

... просто ее мало...

Ну что тут поделаешь...как говориться 7 лет это не время, но срок...

Цитата

1) Использование STL ускоряет написание любых программ в разы.

Я тебе привел пример когда программу твой СТЛ не ускоряет...

Код

typedef enum {    MyParam_NONE,    MyParam_INT,    MyParam_CHAR,    MyParam_STRING,    MyParam_Length } MyParam; int a[ MyParam_Length ]; a[MyParam_INT] = 5; a[MyParam_STRING] = 8;

Выписка из кода, дополнено и исправлено, массив хранит в себе какие то индексы например...

Засунь сюда STL и покажи насколько он будет быстрее...и насколько это вообще нужно.
Добавлено @ 16:45
точнее говоря обясни мне смысл стл -а в данном примере...зачем впихивать в проект вектор?

Цитата(Earnest @ 30.9.2005, 14:41)

Ну, в общем, не совсем это правда - если говорить о хорошей реализации, STL, например. Если не надо расширять vector, то нет там никаких операций перераспределения памяти

если ты не расширяеш вектор, то это уже статический массив