读TXT文件中的数据并且计算期望方差

        最近在做一个小程序，在一个文本文档里有多个数据，并且每个数据以3个空格来间隔。并且每行有64个数据，N多行。
心得如下：
        1.首先在程序里要做的第一个就是访问磁盘中的文件，并且将数据读出来。这里用到了三个库<fstream><string><sstream>

在fstream类中，有一个成员函数open()，就是用来打开文件的，其原型是：
void open(const char* filename,int mode,int access);
参数：
filename：　　要打开的文件名
mode：　　　要打开文件的方式
access：　　　打开文件的属性
打开文件的方式在类ios(是所有流式I/O类的基类)中定义，常用的值如下：
ios::app：　　　以追加的方式打开文件
ios::ate：　　　文件打开后定位到文件尾，ios:app就包含有此属性
ios::binary：　 以二进制方式打开文件，缺省的方式是文本方式。两种方式的区别见前文
ios::in：　　　 文件以输入方式打开（文件数据输入到内存）
ios::out：　　　文件以输出方式打开（内存数据输出到文件）
ios::nocreate： 不建立文件，所以文件不存在时打开失败
ios::noreplace：不覆盖文件，所以打开文件时如果文件存在失败
ios::trunc：　　如果文件存在，把文件长度设为0
　　可以用“或”把以上属性连接起来，如ios::out|ios::binary
　　打开文件的属性取值是：
0：普通文件，打开访问
1：只读文件
2：隐含文件
4：系统文件
　　可以用“或”或者“+”把以上属性连接起来，如3或1|2就是以只读和隐含属性打开文件。
　　例如：以二进制输入方式打开文件c:\config.sys
fstream file1; 
file1.open("c:\\config.sys",ios::binary|ios::in,0); 
　　如果open函数只有文件名一个参数，则是以读/写普通文件打开，即：
file1.open("c:\\config.sys"); <=>file1.open("c:\\config.sys",ios::in|ios::out,0);
　　另外，fstream还有和open()一样的构造函数，对于上例，在定义的时侯就可以打开文件了：
fstream file1("c:\\config.sys");
　　特别提出的是，fstream有两个子类：ifstream(inputfile stream)和ofstream(outpu file stream)，ifstream默认以输入方式打开文件，而ofstream默认以输出方式打开文件。
ifstream file2("c:\\pdos.def");//以输入方式打开文件 

ofstream file3("c:\\x.123");//以输出方式打开文件
　　所以，在实际应用中，根据需要的不同，选择不同的类来定义：如果想以输入方式打开，就用ifstream来定义；如果想以输出方式打开，就用ofstream来定义；如果想以输入/输出方式来打开，就用fstream来定义。

      

字符串流 sstream（常用于格式转换）  

<sstream>库定义了三种类：istringstream、ostringstream和stringstream，分别用来进行流的输入、输出和输入输出操作。另外，每个类都有一个对应的宽字符集版本。简单起见，我主要以stringstream为中心，因为每个转换都要涉及到输入和输出操作。注意，<sstream>使用string对象来代替字符数组。这样可以避免缓冲区溢出的危险。而且，传入参数和目标对象的类型被自动推导出来，即使使用了不正确的格式化符也没有危险。

string到int的转换

string result=”10000”;
int n=0;
stream<<result;
stream>>n;//n等于10000

重复利用stringstream对象

如果你打算在多次转换中使用同一个stringstream对象，记住再每次转换前要使用clear()方法；

在多次转换中重复使用同一个stringstream（而不是每次都创建一个新的对象）对象最大的好处在于效率。stringstream对象的构造和析构函数通常是非常耗费CPU时间的。

在类型转换中使用模板

你可以轻松地定义函数模板来将一个任意的类型转换到特定的目标类型。例如，需要将各种数字值，如int、long、double等等转换成字符串，要使用以一个string类型和一个任意值t为参数的to_string()函数。to_string()函数将t转换为字符串并写入result中。使用str()成员函数来获取流内部缓冲的一份拷贝：

template<class T>

void to_string(string & result,const T& t)

{

 ostringstream oss;//创建一个流

oss<<t;//把值传递如流中

result=oss.str();//获取转换后的字符转并将其写入result
}

这样，你就可以轻松地将多种数值转换成字符串了：

to_string(s1,10.5);//double到string

to_string(s2,123);//int到string

to_string(s3,true);//bool到string

可以更进一步定义一个通用的转换模板，用于任意类型之间的转换。函数模板convert()含有两个模板参数out_type和in_value，功能是将in_value值转换成out_type类型：

template<class out_type,class in_value>

out_type convert(const in_value & t)

{

stringstream stream;

stream<<t;//向流中传值

out_type result;//这里存储转换结果

stream>>result;//向result中写入值

return result;

}

这样使用convert()：

double d;

string salary;

string s=”12.56”;

d=convert<double>(s);//d等于12.56

salary=convert<string>(9000.0);//salary等于”9000”

结论

在过去留下来的程序代码和纯粹的C程序中，传统的<stdio.h>形式的转换伴随了我们很长的一段时间。但是，如文中所述，基于stringstream的转换拥有类型安全和不会溢出这样抢眼的特性，使我们有充足得理由抛弃<stdio.h>而使用<sstream>。<sstream>库还提供了另外一个特性—可扩展性。你可以通过重载来支持自定义类型间的转换。

一些实例：

stringstream通常是用来做数据转换的。

相比c库的转换，它更加安全，自动和直接。

 

例子一：基本数据类型转换例子 int转string

 

#include <string>
#include <sstream>
#include <iostream> 

int main()
{
    std::stringstream stream;
    std::string result;
    int i = 1000;
    stream << i; //将int输入流
    stream >> result; //从stream中抽取前面插入的int值
    std::cout << result << std::endl; // print the string "1000"
} 

 

 

运行结果：

 

例子二：除了基本类型的转换，也支持char *的转换。

 

# include <sstream>
# include <iostream> 

int main()
{
    std::stringstream stream;
    char result[8] ;
    stream << 8888;  // 向stream中插入8888
    stream >> result;  // 抽取stream中的值到result
    std::cout << result << std::endl;  //  屏幕显示 "8888"
} 

 

 

 

例子三：再进行多次转换的时候，必须调用stringstream的成员函数clear().

 

# include <sstream>
# include <iostream>
int main()
{
    std::stringstream stream;
    int first, second;
    stream<< "456";  // 插入字符串
    stream >> first;  // 转换成int
    std::cout << first << std::endl;
    stream.clear();  // 在进行多次转换前，必须清除stream
    stream <<  true;  // 插入bool值
    stream >> second;  // 提取出int
    std::cout << second << std::endl;
} 

 

运行clear的结果

没有运行clear的结果

注：关于stream.clear()和stream.str("")，作用还不太清楚。又说clear是清除标志位，str("")是清楚stream内容的。但在多次转换过程是，的确是使用clear才准确，这是验证过的。

附录：

代码

// ylh1.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;




int main()
{
 
ifstream ifile;
ifile.open("d:\\1.txt");// 打开文件
ofstream out;
out.open("d:\\2.txt",ofstream::out);// 打开文件
string line; // 用于存放从文件读取的每一行




  double arr1[64]; 
  int n=64;
  double s=0.00;


 if (ifile) // 检查文件是否打开成功
 {
 while(!ifile.eof())
 {
 getline(ifile, line); // 读取文件第一行
 if(line=="一帧结束")//读到一帧结束 就跳过去
 {line.empty();
 getline(ifile,line);
 }
 istringstream instr1(line); // 将第一行绑定给 istringstream 对象


 for (int x = 0; x != 64; ++x)
 {
  instr1 >> arr1[x] ;
 }

 //均值s和方差f
 for(int i=0;i<n;i++)
{
s+=arr1[i];
}
s/=n;

   


double f=0.00;
for(int i=0;i<n;i++)
{
f+=(arr1[i]-s)*(arr1[i]-s);
}
f/=n;



                    //第一块均值与方差
double s1=0;
for(int i=0;i<4;i++)
{for(int j=0;j<=24;j+=8)
s1+=arr1[i+j];
}
s1=s1/16;

                    double f1=0;
for(int i=0;i<3;i++)
{  for(int j=0;j<=24;j+=8)
f1+=(arr1[i+j]-s1)*(arr1[i+j]-s1);
}
f1/=16;
                    




//第二块均值与方差
double s2=0;
for(int i=4;i<8;i++)
{for(int j=0;j<=24;j+=8)
s2+=arr1[i+j];
}
s2=s2/16;

                    double f2=0;
for(int i=4;i<8;i++)
{  for(int j=0;j<=24;j+=8)
f2+=(arr1[i+j]-s2)*(arr1[i+j]-s2);
}
f2/=16;
                  




//第三块均值与方差
double s3=0;
for(int i=32;i<36;i++)
{for(int j=0;j<=24;j+=8)
s3+=arr1[i+j];
}
s3=s3/16;

                    double f3=0;
for(int i=32;i<36;i++)
{  for(int j=0;j<=24;j+=8)
f3+=(arr1[i+j]-s3)*(arr1[i+j]-s3);
}
f3/=16;
                   




//第四块均值与方差
double s4=0;
for(int i=36;i<40;i++)
{for(int j=0;j<=24;j+=8)
s4+=arr1[i+j];
}
s4=s4/16;

                    double f4=0;
for(int i=36;i<40;i++)
{  for(int j=0;j<=24;j+=8)
f4+=(arr1[i+j]-s4)*(arr1[i+j]-s4);
}
f4/=16;
                    
                    line.empty();
                     


                     ostringstream oss;
string result;
oss<<"均值是:"<<s<<"\n";//把值传递如流中
oss<<"方差是："<<f<<"\n";
oss<<"块1均值："<<s1<<"\n";
oss<<"块1方差："<<f1<<"\n";
oss<<"块2均值："<<s2<<"\n";
oss<<"块2方差："<<f2<<"\n";
oss<<"块3均值："<<s3<<"\n";
oss<<"块3方差："<<f3<<"\n";
oss<<"块4均值："<<s4<<"\n";
oss<<"块4方差："<<f4;


                     result=oss.str();//转换后的字符转并将其写入result
 




 
if(out.is_open())


{
 out<<result<<endl;
 out<<"一帧结束"<<endl;
 out<<endl;

 
}

        result.empty();

 



 }
 }






 else
 {
 cout << "打开文件1错误！" << endl;
  return EXIT_FAILURE;
 }


 ifile.close();
 out.close();
    return 0;


}