C++钱能DataTypes

C++中的数据类型，有语言既定的内部数据类型，也有程序员自定义的外部数据类型。
内部数据类型：
整数类型（int）
字符类型（char）
布尔类型（bool）
单精度浮点（float）
双精度浮点（double）
还可以通过数组、指针、引用等来定义基于上面这些数据类型以及其他外部数据类型的编译类型。例如：
整型数组（int[]）
浮点引用（double&）
字符指针（char*）

程序员自定义的数据类型主要是指用class关键字狗仔的数据类型。除此之外，用enum、union、struct关键字也能定义单纯空间意义上的数据类型。

整型

1、二进制补码
2、整型数表示范围



３、编译器与整数长度

一、整数子类

1.1、字符型（char type）
转义字符

生成一个字母正三角形

#include<iostream>
#include<string>
using namespace std;

int main()
{
    for(int i=1; i<=10; ++i)
    {
        cout<<string(10-i, ' ');
        for(char ch='A'; ch<=64+2*i; ++ch)
            cout<<ch;
        cout<<endl;
    }
    system("pause");
}

结果展示

1.2、枚举型（enum type）

枚举型是对整数区间的自定义类型，用户还可以为区间中的值取名，例如：
enum Week{Mon,Tue,Wed,Thu,Fri,Sat,Sun};

定义枚举时，其花括号中的名称代表某个整数值，默认时，第一个名称对应整数0，第二个对应1，以此类推。因此，Week中，Mon=0,Tue=1,…,Sun=6.
也可以认为规定，例如：enum Color{Red=5,Green,Yellow,Blue=20,Orange};
则Green对应6，Yellow对应7，Orange对应21。


枚举符一旦定义则不能改变。所以它常常代替整数常量使用。这才是语言设计枚举的真实意图。有时候甚至比整数常量还管用，因为在进入函数调用或其他模块时，常量需要初始化，而枚举缺失一种类型，无须定义其尸体，便可以直接使用其枚举符。

1.3、布尔型（bool type）

整数1和0两个值构成了bool型的表示范围。相当于：
enum bool{false, true};
bool型
的输出形式可以选择，默认为整数1和0，如果要输出true和false，则可用输出控制符：cout<<boolalpha<<d<<endl; //输出结果为：false
**

二、浮点型（float type）

**

用程序查看单精度浮点数的二进制码

#include<iostream>
#include<string>
using namespace std;

int main()
{
    float f= 19.2F;
    unsigned int* pa = reinterpret_cast<int*>(&f);
    for (int i =31; i>=0; i--)
    {
        cout<<(*pa>>i & 1)<<(i==31||i=23?"-":"");
    }
    cout<<"\n";
    system("pause");
}

**

三、C-串与string

**
3.1、C-串
C-串的空间长度为字符串长度家1.如果要将C-串放入字符数组，则元素个数非比字符数多1不可。例如：

char buffer[7]="Hello!";//若为char buffer[6]="Hello!";则为错误

3.2、字符指针与字符数组
指针式表示内存空间位置的类型。字符指针就是所指向的空间位置上的值，当作字符来操作的类型。

3.3、C-串操作

#include<iostream>
#include<string>
using namespace std;

int main()
{
    char* s1 = "Hello";
    char* s2 = "123";
    char a[20];
    strcpy(a,s1);                                   //复制
    cout<<(strcmp(a,s1)==0 ? "" :"not")<<"equal\n"; //比较
    cout<<strcat(a,s2)<<endl;                       //连接
    cout<<strrev(a)<<endl;                          //倒置
    cout<<strset(a,'c')<<endl;                      //设置
    cout<<(strstr(s1,"ell")? "" :"not")<<"found\n"; //查找串
    cout<<(strchr(s1,'c') ? "" : "not")<<"found\n"; //查找字符
    system("pause");
}

3.4、string

string是一种自定义的类型，它可以方便地执行C-串所不能执行的一切操作。它处理空间占用问题是自动的，需要多少，用多少。它可从C-串转换得到，还可以从内部“提炼”出C-串
。

由于字符指针所指向的空间受认为操作的控制，因此它会导致许多编程中的低级错误。

3.5、string与C-串的输入与输出

getline的使用

3.6、string流

若有一个文件aaa.txt，有若干行，不知道每行中含有几个整数，要变成输出每行的整数和

#include<iostream>
#include<sstream>
#include<fstream>
using namespace std;

int main()
{
  ifstream in("aaa.txt");
  for (string s; getline(in, s);)
  {
     int a, sum=0;
     for(istringstream sin(s); sin>>a; sum += a);
     cout<<sum<<endl;
  }
  system("pause");
}

getline（istream &in, string &s）
从输入流读入一行到string s
•功能：
–从输入流中读入字符，存到string变量
–直到出现以下情况为止：
•读入了文件结束标志
•读到一个新行
•达到字符串的最大长度
–如果getline没有读入字符，将返回false，可用于判断文件是否结束

3.7、数组（arrays）

int a[5];  //可以访问的元素为a[0]-a[4],不能访问a[5]

下面这段代码的数组定义是错误的

int n=100;
int a[n];     //错：数组元素个数必须是常量

正确的定义应为如下所示
const int n=100;
int a[n];

3.8、初始化（initialization）

只要使用了花括号，就是实施了初始化。对于实施初始化的数组，如果初试个数不足等号左边方括号中规定的元素个数，则后面的元素值全为0.具有初始化的数组定义，其元素个数可以省略，这是，最后确定的元素个数取决于初始化的个数。

字符数组的初始化形式

3.9、默认值（default value）
对于没有初始化的数组，分两种情况：
一种是全局数组和静态数组，也就是在函数外部定义的，或者加上static修饰的数组定义，其元素总是全被清0；

另一种是局部数组，就是在函数内部定义的数组，他们的值是不确定的。

#include<iostream>
using namespace std;

int array1[5]={1,2,3};      //有初始化
int array2[5];              //无初始化

int main ()
{
    int array3[5]={2};      //有初始化
    int array4[5];          //无初始化
    cout<<"array1:";
    for (int i=0; i<5; ++i)
        cout<<array1[i]<<" ";
    cout<<"\narray2:";
    for (int i=0; i<5; ++i)
        cout<<array2[i]<<" ";
    cout<<"\narray3:";
    for (int i=0; i<5; ++i)
        cout<<array3[i]<<" ";
    cout<<"\narray4:";
    for (int i=0; i<5; ++i)
        cout<<array4[i]<<" ";
    cout<<"\n";


    system("pause");
}

3.10、二维数组

int a[3][5];     //定义二维数组
int a[3][5]={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};  //初始化二维数组

3.11、向量（Vectors）
vector是响亮类型，它是一种对象尸体，具有值，所以可以看作是变量。它可以容纳许多其他类型的相同实体，如若干个整数，所以称其为容器。

使用它时，只用包含头文件vector即可。

要输出向量中所有元素，可以有两种循环控制方式：

int a[7]={1,2,3,4,5,6,7};
    vector<int> va(a,a+7);
    for (int i=0; i<va.size(); ++i)     //第一种
        cout<<va[i]<<" ";
    for(vector<int>::iterator it=va.begin(); it!=va.end();++it)     //第二种
        cout<<*it<<" ";

第一种形式是下标方式，a[i]是向量元素操作，这种形式与数组一样；第二种形式是遍历器方式，*it是指针间访形式，它的意义是it所指向的元素值。
va.size()是向量中元素的个数，va.begin()表示向量的第一个元素，这种操作方式是一个对象捆绑一个函数调用 。

向量中的操作都是通过使用成员函数来完成的。它的常用操作有：

3.12、添加元素
读入一个文件aaa.txt的数据到向量中，文件中为一些整数。要判断向量中的元素有多少个两两相等的数对。

    ifstream in ("aaa.txt");
    vector<int> s;
    for(int a; in>>a;)
        s.push_back(a);
    int pair=0;
    for(int i=0; i<s.size()-1; ++i)
        for(int j=i+1; j<s.size(); ++j)
            if (s[i]==s[j])
                pair++;
    cout<<pair<<"\n";

3.13、二维向量

在二位向量中，可以使用vector中的swap操作来交换两个向量。

viod swap(vector<int>& a, vector<int>& b)
{
    vector<int> temp =a; a=b; b=temp;
}

若干个向量按长短排序

//若干个向量按长短排序

#include<iostream>
#include<vector>
#include<sstream>
#include<fstream>

using namespace std;

typedef vector<vector<int>> Mat;
Mat input();
void mySort(Mat& a);
void print(const Mat& a);


int main()
{
    Mat a = input();
    mySort(a);
    print(a);
    system("pause");
}

Mat input()
{
    ifstream in("aaa.txt");
    Mat a ;
    for(string s; getline(in, s);)
    {
        vector<int> b;
        istringstream sin(s);
        for(int ia; sin>>ia;)
            b.push_back(ia);
        a.push_back(b);
    }
    return a ;
}

void mySort(Mat& a)
{
    for(int pass=1; pass<a.size(); ++pass)
        for(int i=0; i<a.size()-pass; ++i)
            if (a[i+1].size()<a[i].size())
                a[i].swap(a[i+1]);
}

void print (const Mat& a)
{
    for (int i=0; i<a.size(); ++i)
    {
        for(int j=0; j<a[i].size(); ++j)
            cout<<a[i][j]<<" ";
        cout<<endl;
    }
}