Как вывести массив двойников на жесткий диск?

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

редактировать:

для дальнейшего уточнения. Я хотел бы вывести его в файл на жестком диске (функции ввода / вывода). Предпочтительно в формате файла, который можно быстро перевести обратно в массив двойников в другой программе. Также было бы хорошо, если бы он был сохранен в стандартной 4-байтовой конфигурации, чтобы я мог посмотреть на нее через шестнадцатеричный просмотрщик и увидеть фактические значения.

 Alan Haggai Alavi07 июл. 2009 г., 07:03
Вы имеете в виду вывод в файл?
 John T07 июл. 2009 г., 07:04
На жесткий диск? Быть конкретными. В текстовый файл? В каком формате? 1 на строку? ...

Ответы на вопрос(6)

: copy () с потоковыми итераторами. Таким образом, если вы измените «данные» в другой тип изменения кода будут тривиальными.

#include <algorithm>
#include <iterator>
#include <fstream>

int main()
{
    double         data[1000] = {/*Init Array */};

    {
        // Write data too a file.
        std::ofstream   outfile("data");
        std::copy(data,
                  data+1000,
                  std::ostream_iterator<double>(outfile," ")
                 );
    }

    {
        // Read data from a file
        std::ifstream    infile("data");
        std::copy(std::istream_iterator<double>(infile),
                  std::istream_iterator<double>(),
                  data // Assuming data is large enough.
                 );
    }
}
 08 июл. 2009 г., 08:03
Мне нравится этот стиль, но он еще лучше, если вы используете вектор & lt; double & gt; вместо массива и back_inserter (data) вместо данных в копии из ifstream.
 08 июл. 2009 г., 08:21
Или список или набор или просто что-нибудь еще. Все они работают с незначительными изменениями.
#include <fstream.h>

void saveArray(double* array, int length);

int main()
{
    double array[] = { 15.25, 15.2516, 84.168, 84356};
    saveArray(array, 4);

    return 0;
}

void saveArray(double* array, int length)
{
    ofstream output("output.txt");

    for(int i=0;i<length;i++)
    {
        output<<array[i]<<endl;
    }
}

ому на строку. надеюсь это поможет
EDIT
Измените одну верхнюю строку на две, и она будет скомпилирована в VS. Вы можете использовать многопоточность, чтобы не блокировать системное сохранение данных

#include <fstream>

using namespace std;
 07 июл. 2009 г., 07:52
смотрите отредактированный пост, для компиляции в VS
 Faken07 июл. 2009 г., 07:19
Хм, спасибо за ваш ответ. По некоторым причинам он не компилируется на моем VC ++. Даже при том, что он не компилируется, все еще существует проблема использования цикла для вывода всего. По моему опыту, это намного медленнее, чем использование .write (). Поскольку я выдаю миллионы двойных чисел, это будет очень-очень медленно, мне нужно что-то быстрое и эффективное, нет!

Это работает (очень грубо!) Так:

double d[2048];
fill(d, d+2048, 0);
ofstream outfile ("save.bin", ios::binary);
outfile.write(reinterpret_cast<char*>(&d), sizeof(d));

ifstream infile ("save.bin", ios::binary);
infile.read(reinterpret_cast<char*>(&d), sizeof(d));

Обратите внимание, что этоnot portable между процессорами архитектуры. Некоторые могут иметьdifferent sizes двойной. Некоторые могут хранить байты вdifferent order, Его не следует использовать для файлов данных, которые перемещаются между компьютерами, или данных, которые передаются по сети.

 Faken08 июл. 2009 г., 06:06
Я реализовал это, и в конечном итоге я получил странные ошибки повсюду, на самом деле случайные странные ошибки, которые иногда случаются, а иногда и нет ... даже между двумя отдельными, но одинаковыми запусками программы.
 07 июл. 2009 г., 17:55
Я бы выделил целое первое предложение вашего отказа от ответственности.
 07 июл. 2009 г., 18:16
хотел сказатьshouldn't быть * .txt
 07 июл. 2009 г., 18:16
Я знаю, что это придирчиво, но файл должен быть * .txt, если вы сохраняете как бинарный файл.
 08 июл. 2009 г., 07:58
Вы должны установить массив на что-то, прежде чем использовать его. Пример кода - это не то, что вы можете использовать как есть, это просто пример.
#include <iostream>
#include <fstream>

using namespace std;

int main () {
  double [] theArray=...;
  int arrayLength=...;
  ofstream myfile;
  myfile.open ("example.txt");
  for(int i=0; i<arrayLength; i++) {
    myfile << theArray[i]<<"\n";
  }
  myfile.close();
  return 0;
}

http://www.cplusplus.com/doc/tutorial/files/

Просто установите Array и arrayLength на то, что требуется вашему коду.

 Faken07 июл. 2009 г., 07:23
Есть ли другой способ, кроме вывода каждого элемента по отдельности? Это слишком медленно для моего приложения. Есть ли какой-нибудь способ сказать компьютеру: «Эй! Возьмите материал, в котором хранится двойной массив в ОЗУ, и просто скопируйте его в файл и добавьте .txt в его конец & quot; ?
 07 июл. 2009 г., 07:19
Вы имеете в виду myfile & lt; & lt; theArray [i] & lt; & lt; & Quot; \ п & Quot ;; ? В противном случае вы просто будете многократно печатать литерал theArray [i].
 07 июл. 2009 г., 20:13
Дисковое кэширование делает запись каждого индивидуально так же быстро, как запись всего сразу.
 07 июл. 2009 г., 07:33
Если запись каждого элемента слишком медленная, почему бы просто не создать строку из всех записей и записать эту строку на диск?
Решение Вопроса

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

#include <string>
#include <fstream>
#include <iostream>

bool saveArray( const double* pdata, size_t length, const std::string& file_path )
{
    std::ofstream os(file_path.c_str(), std::ios::binary | std::ios::out);
    if ( !os.is_open() )
        return false;
    os.write(reinterpret_cast<const char*>(pdata), std::streamsize(length*sizeof(double)));
    os.close();
    return true;
}

bool loadArray( double* pdata, size_t length, const std::string& file_path)
{
    std::ifstream is(file_path.c_str(), std::ios::binary | std::ios::in);
    if ( !is.is_open() )
        return false;
    is.read(reinterpret_cast<char*>(pdata), std::streamsize(length*sizeof(double)));
    is.close();
    return true;
}

int main()
{
    double* pDbl = new double[1000];
    int i;
    for (i=0 ; i<1000 ; i++)
        pDbl[i] = double(rand());

    saveArray(pDbl,1000,"test.txt");

    double* pDblFromFile = new double[1000];
    loadArray(pDblFromFile, 1000, "test.txt");

    for (i=0 ; i<1000 ; i++)
    {
        if ( pDbl[i] != pDblFromFile[i] )
        {
            std::cout << "error, loaded data not the same!\n";
            break;
        }
    }
    if ( i==1000 )
        std::cout << "success!\n";

    delete [] pDbl;
    delete [] pDblFromFile;

    return 0;
}

Просто убедитесь, что вы выделяете соответствующие буферы! Но это целая другая тема.

 08 июл. 2009 г., 08:01
Не уверен, почему вы оценили этот вариант лучше как переносимый. Он использует тот же двоичный файл для чтения / записи, что и мой ответ, и все проблемы с переносимостью все еще существуют. Вот этотis более полный ответ, будучи целой программой, а не просто фрагментом кода.
 Faken08 июл. 2009 г., 06:08
Странно, почему за него больше не голосовали, на самом деле он намного лучше с точки зрения мобильности. Большое спасибо, все работало отлично, и я кое-что узнал!

насчет целых). ссылка comp.lang.c ++

Ваш ответ на вопрос