C++ 如何将双工阵列输出到硬盘驱动器？

我想知道如何向硬盘输出一组双精度阵列

编辑：

请进一步澄清。我想将其输出到硬盘上的文件（I/O功能）。最好是文件格式，可以在另一个程序中快速转换回一个双精度数组。如果它存储在标准的4字节配置中，这样我就可以通过十六进制查看器查看它并查看实际值，那也太好了

#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;
    }
}

void saveArray（双*数组，整数长度）； int main（） { 双数组[]={15.25,15.2516,84.168,84356}； saveArray（数组，4）； 返回0； } void saveArray（双*数组，整数长度） { 流输出（“output.txt”）； 对于（int i=0；i

#包括
#包括
使用名称空间std；
int main（）{
双[]数组=。。。；
整数数组长度=。。。；
流文件；
myfile.open（“example.txt”）；
对于（int i=0；i

只需将array和arrayLength设置为代码所需的长度。
您可以使用iostream.read（）和.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));

double d[2048]；
填充（d，d+2048，0）；
流输出文件（“save.bin”，ios:：binary）；
outfile.write（重新解释铸件（&d），尺寸（d））；
ifstream-infle（“save.bin”，ios:：binary）；
填充读取（重新解释铸件，尺寸（d））；

请注意，这在CPU体系结构之间是不可移植的。有些可能具有不同大小的双字节。有些可能以不同的顺序存储字节。它不应用于在机器之间移动的数据文件或通过网络发送的数据。
嘿…所以你想用一个write/read，这不太难，以下代码应该可以正常工作，可能需要一些额外的错误检查，但审判案例成功：

#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;
}

#包括
#包括
#包括
bool saveArray（常量double*pdata、大小长度、常量std:：字符串和文件路径）
{
流操作系统的std:：of（文件_path.c_str（），std:：ios:：binary | std:：ios:：out）；
如果（！os.is_open（））
返回false；
写入（重新解释强制转换（pdata），标准：：streamsize（长度*大小f（双精度））；
os.close（）；
返回true；
}
bool loadArray（双*数据、大小长度、常量std:：字符串和文件路径）
{
ifstream是（file_path.c_str（），std:：ios:：binary | std:：ios:：in）；
如果（！is.is_open（））
返回false；
is.read（reinterpret_cast（pdata），std:：streamsize（长度*sizeof（双精度））；
is.close（）；
返回true；
}
int main（）
{
double*pDbl=新的double[1000]；
int i；
对于（i=0；i使用std:：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.
                 );
    }
}

#包括
#包括
#包括
int main（）
{
双数据[1000]={/*Init数组*/}；
{
//将数据写入文件。
标准：流出管（“数据”）；
复制（数据、，
数据+1000，
std:：ostream_迭代器（outfile，“”）
);
}
{
//从文件中读取数据
标准：：ifstream INFLE（“数据”）；
std:：copy（std:：istream_迭代器（infle），
std:：istream_迭代器（），
数据//假设数据足够大。
);
}
}
现在我觉得自己老了。我很久以前就问过这个问题（关于ints的问题除外）。
您的意思是，输出到文件？到硬盘？具体点。到文本文件？以什么格式？每行1个？…您的意思是myfile除了单独输出每个元素之外，还有其他方法吗？对于我的应用程序来说，速度太慢了。有什么方法可以对计算机说：“嘿！拿双数组存储在RAM中的东西，把它转储到一个文件中，然后在它的末尾打一个.txt。”"？如果写入每个元素的速度太慢，为什么不构造一个包含所有条目的字符串并将该字符串写入磁盘？磁盘缓存使单独写入每个元素的速度与一次写入所有元素的速度一样快。嗯，感谢您的回复。由于某种原因，它似乎无法在我的VC++上编译。即使它没有编译，仍然存在错误使用循环输出所有内容的问题。根据我的经验，它比使用.write（）慢得多.因为我要输出数百万个翻倍，速度会非常慢，我需要一些快速有效的东西！我会将你的免责声明的第一句话全部加粗。我知道这很挑剔，但如果你保存为二进制文件，文件应该是*.txt。我的意思是说不应该是*.txtI实现了这一点，结果我整个星期都出现了奇怪的错误呃，这个地方，实际上有时候会发生随机奇怪的错误，有时候不会…甚至在两次独立但完全相同的程序运行之间。你必须在使用之前将数组设置为某个值。代码示例不是你可以使用的东西，它只是一个示例。奇怪的是，为什么这一个没有得到更多的投票，它实际上非常重要tter在可移植性方面。非常感谢，它工作得很好，我学到了一些东西！不知道为什么你会对这一个的可移植性评价更高。它使用与我的答案相同的二进制读/写，所有的可移植性问题仍然存在。这一个是一个更完整的答案，是一个完整的程序，而不仅仅是一个代码剪贴。我喜欢这种风格，但它的特点如果您使用向量而不是数组，使用back_inserter（数据）而不是ifstream副本中的数据，或者使用列表、集合或其他任何东西，则效果更好。它们都只需稍作更改即可工作。
#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;
}

#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.
                 );
    }
}