C++学习随笔2-数据类型

1. Int Type:

C++编译器在不同的计算机硬件上的表现是不同的。所谓32位编译器是指它能将程序源代码编译成最高为32位的CPU指令系统代码。或者更加直接地说，int类型的长度是32位的。

例如，在32位编译器中，若将代码编译成16位机指令系统，则：

int a = 327777；   //错，16位机器指令表示的有符号整数最大只能为32767 = 2¹⁵-1

2. char Type：

ASCII码有128个字符，其中ASCII从0~31和127为不可见字符（控制字符），可以用signed char（即char）中的所有正数表示所有ASCII码值。char与int最大的区别在输出上，char输出的不是整数，而是该整数所代表的ASCII码字符。例如：

　　int a = 65；

　　char b = 65；

　　cout<<a<<" "<<b<<endl;            //虽其值都为65，但其结果为65  A

3. enum Type:

4. float Type:

float 单精度 32位 4字节

double 双精度 64位 8字节

long double 长双精度 80位 10字节

5. C-strings&string

6. string流

C++的输入输出分为三种：

(1)基于控制台的I/O

    

(2)基于文件的I/O

    

(3)基于字符串的I/O

    

1、头文件

#include <sstream>  

2、作用

istringstream类用于执行C++风格的字符串流的输入操作。 

ostringstream类用于执行C++风格的字符串流的输出操作。 

strstream类同时可以支持C++风格的串流的输入输出操作。

3、具体分析

istringstream类

描述：从流中提取数据，支持 >> 操作

这里字符串可以包括多个单词，单词之间使用空格分开

初始化：使用字符串进行初始化

istringstream istr("1 56.7");  
istr.str("1 56.7");//把字符串"1 56.7"存入字符串流中   

使用：我们可以使用分解点获取不同的数据，完成 字符串 到 其他类型 的转换

常用成员函数：

str()：使istringstream对象返回一个string字符串  

应用1：把字符串类型的数据转换为其他类型数据

#include <iostream>   
#include <sstream>   
using namespace std;  
int main()  
{  
    istringstream istr("1 56.7");  
  
    cout<<istr.str()<<endl;//直接输出字符串的数据 "1 56.7"   
      
    string str = istr.str();//函数str()返回一个字符串   
    cout<<str<<endl;  
      
    int n;  
    double d;  
  
    //以空格为界，把istringstream中数据取出，进行类型转换   
    istr>>n;//第一个数为整型数据，输出1   
    istr>>d;//第二个数位浮点数，输出56.7   
  
    //假设换下存储类型   
    istr>>d;//istringstream第一个数要自动变成浮点型，输出仍为1   
    istr>>n;//istringstream第二个数要自动变成整型，有数字的阶段，输出为56   
  
    //测试输出   
    cout<<d<<endl;  
    cout<<n<<endl;  
    system("pause");  
    return 1;  
}  

应用2：把一行字符串放入流中，单词以空格隔开。之后把一个个单词从流中依次读取到字符串

#include <iostream>   
#include <sstream>   
using namespace std;  
int main()  
{  
    istringstream istr;  
    string line,str;  
    while (getline(cin,line))//从终端接收一行字符串，并放入字符串line中   
    {  
        istr.str(line);//把line中的字符串存入字符串流中   
        while(istr >> str)//每次读取一个单词（以空格为界），存入str中   
        {  
            cout<<str<<endl;  
        }  
    }  
    system("pause");  
    return 1;  
}  

输入：123 34 45

输出：

123

34

45

ostringstream类

描述：把其他类型的数据写入流(往流中写入数据)，支持<<操作

初始化：使用字符串进行初始化

ostringstream ostr("1234");  
ostr.str("1234");//把字符串"1234"存入字符串流中  

应用：

#include <iostream>   
#include <sstream>   
using namespace std;  
int main()  
{  
    //初始化输出字符串流ostr   
    ostringstream ostr("1234");  
    cout<<ostr.str()<<endl;//输出1234   
      
    ostr.put('5');//字符5顶替了1的位置   
    cout<<ostr.str()<<endl;//输出5234   
  
    ostr<<"67";//字符串67替代了23的位置，输出5674，而不是6734因为流（先输入5，再输入67）   
    string str = ostr.str();  
    cout<<str<<endl;  
    system("pause");  
    return 1;  
}          

stringstream类

描述：是对istringstream和ostringstream类的综合，支持<<, >>操作符，可以进行字符串到其它类型的快速转换

初始化：使用字符串进行初始化

stringstream str("1234");  
str.str("1234");//把字符串"1234"存入字符串流中  

作用：

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

2、将文件的所有数据一次性读入内存

举例1：基本数据类型变字符串

/*基本数据类型变字符串*/  
#include <fstream>   
#include <iostream>   
#include <sstream>   
using namespace std;  
int main()  
{  
    /*整型变字符串*/  
    int n = 10;  
    string str;  
    stringstream stream;  
      
    stream << n;  
    stream >> str;  
      
    cout<<str<<endl;  
    stream.clear();//多次使用stringstream，要先清空下，不能使用stream.str("");否则下面输出10   
  
    /*char* 变 string*/  
    char cStr[10] = "china";  
      
    stream << cStr;  
    stream >> str;  
  
    cout<<str<<endl;  
    system("pause");  
    return 1;  
}  

举例2：字符串变基本数据类型

/*字符串变基本数据类型*/  
#include <fstream>   
#include <iostream>   
#include <sstream>   
using namespace std;  
int main()  
{  
    /*字符串 变 double*/  
    double n;  
    string str = "12.5";  
    stringstream stream;  
      
    stream << str;  
    stream >> n;  
      
    cout<<n<<endl;  
    stream.clear();//多次使用stringstream，要先清空下,不能使用stream.str("");   
  
    /*string 变 char* */  
    string str1 = "china";  
    char cStr[10];  
      
    stream << str1;  
    stream >> cStr;  
  
    cout<<cStr<<endl;//输出china   
    system("pause");  
    return 1;  
}  

注意：
我们定义要输入到的变量是整型,但如果我们输入了英文字母或者汉字,那就会发生错误，不能继续输入或操作。
1、每一个输入（输出）对象就代表一个输入（输出）流
2、输入（输出）对象中的流状态成员标记了输入（输出）流当前的状况，当eofbit、badbit、failbit三个标记位均为0时表示流状态正常
3、一但某个或几个标记位被设置，表示对象的流状态出现相应状况，流将对后面的输入（输出）关闭，直到标记位被清除
4、只有在流状态良好的情况下，if或者while对该输入（输出）对象的判断才能是true

1、cin状态有下面几种：

常量	含义	failbit标记位的值	eofbit标记位的值	badbit标记位的值	goodbit标记位的值
ios::failbit	输入（输出）流出现非致命错误，可挽回	1	0	0	0
ios::badbit	输入（输出）流出现致命错误，不可挽回	0	0	1	0
ios::eofbit	已经到达文件尾	0	1	0	0
ios::goodbit	流状态完全正常	0	0	0	1

分别对应cin.fail(),cin.bad(),cin.eof(),cin.good()

#include <iostream>   
#include <sstream>   
using namespace std;  
  
int main(int argc,char *argv[])  
{  
    std::stringstream stream;  
    string str;  
    while(1)  
    {     
        //clear()，这个名字让很多人想当然地认为它会清除流的内容。   
        //实际上，它并不清空任何内容，它只是重置了流的状态标志而已！   
        stream.clear();    
  
        // 去掉下面这行注释，清空stringstream的缓冲，每次循环内存消耗将不再增加!   
        //stream.str("");         
  
        stream<<"sdfsdfdsfsadfsdafsdfsdgsdgsdgsadgdsgsdagasdgsdagsadgsdgsgdsagsadgs";  
        stream>>str;     
  
        //测试输出每次循环，你的内存消耗增加了多少！   
        cout<<"Size of stream = "<<stream.str().length()<<endl;  
        system("PAUSE");  
    }  
  
    system("PAUSE");  
    return EXIT_SUCCESS;  
}  

由于stringstream构造函数会特别消耗内存，似乎不打算主动释放内存(或许是为了提高效率)，但如果你要在程序中用同一个流，反复读写大量的数据，将会造成大量的内存消耗，因些这时候，需要适时地清除一下缓冲 (用 stream.str("") )。

另外不要企图用 stream.str().resize(0)，或 stream.str().clear() 来清除缓冲，使用它们似乎可以让stringstream的内存消耗不要增长得那么快，但仍然不能达到清除stringstream缓冲的效果，内存的消耗还在缓慢的增长！，至于stream.flush()，则根本就起不到任何作用。

7.数组

数组元素个数=sizeof(a)/sizeof(a[0])

8.向量（Vectors）

vector可以有四种定义方式：

(1) vector<int> s;           //创建向量变量，但没有长度
(2) vector<int> a(10);       //定义了长度为10的向量，没有初始化
(3) vector<int> b(10, 1);    //给每个元素赋值为1
(4) vector<int> c(b);        //用一个向量去初始化另一个向量
(5) vector<int> d(b.begin(), b.begin() + 3);
(6) vector<int> e(x, x+10);  //用数组去初始化向量

每种容器都有对应的遍历器，遍历器不单表示元素位置，还可以在容器中前后移动。向量中的遍历器类型为：

vector<int>::iterator

因此要输出向量中所有元素，有两种循环控制方法：

1. 下标方式：

for(int i = 0; i < a.size(); i++)
    cout<<a[i]<<endl;

2. 遍历器方式：

for(vector<int>::iterator  it = a.begin(); it != a.end(); it++)
    cout << *it << endl;

9. 指针和引用

1. 指针变量所占的空间大小总是等于整型变量的大小。

常量指针：指向常量的指针(不能通过ip修改a的值，但a的值可以被别的方式改变)

const int* ip = &a;

指针常量：指针值不能修改的指针

int* const cp = &b;  或 int const* dp = &b;

常量指针常量:

const int* const icp = &c;

2. 引用定义时必须初始化，这是它与指针根本不同的地方。

int int1 = 5;
int & rInt = int1;       //&rInt和&int1 地址值相同

引用不能操作自身的地址值，每次访问rInt，实际上是在访问所指向的int1实体，所以与指针比较，引用隐去了地址操作，封锁了这种地址的可修改性，使得间接访问操作相对来说更安全，所以高级编程多用引用。