笔试时C++的输入输出汇总

一、基础概念

二、一维整型数组的输入

三、字符串的输入输出

四、二维整型数组的输入输出

五、二维字符数组的输入输出

六、链表节点的定义

七、二叉树的定义

一、基础概念

C++语言未定义任何输入输出语句，而是使用标准库（standard library）来提供IO机制。

#include
cin>>
cout<<   //cout略过空白符（空白、新行、tabs）直到它遇到非空白符

两种常用的输入模式：

1）cin>>x

从缓冲区读数据到变量x，而不是从键盘输入读取；

对于一个变量，cin自动跳过tab/space/enter取数据，到与目标类型不匹配的第一个字符之间的全部内容；

不匹配的内容（空格/换行符）将被保存在输入缓冲流中，参与下一次的读取，如果接下来还是用cin读取，cin会跳过这个换行符继续下一行数据的读取，不会受影像

       istream类提供了一个可以将istream对象(如cin)转换为bool值的函数，当cin出现在需要bool类型的地方(如在while循环测试条件中)，该转换函数将被调用；如果读取成功，转换为true,如果读取失败，转换为false。当cin检查输入被放在循环条件中来终止循环，需要注意的是循环终止后不再允许用户输入，即使调用cin>>也没用；如需要用户输入，则需要设置标识符为有效才可。

2)getline(cin,x)

需要#include头文件；

getline()函数的全部参数为getline(istream& is,string& str,结束符)，is是一个流，例如cin,str是一个string类型的引用，读入的字符串将直接保存在str里面，默认结束符为换行符'\n'；

可以读入SPACE/TAB,遇到ENTER停止读取，且读取完成后会丢弃换行符，后续的getline不用考虑这个换行符的存在了；

当同时使用cin>> ,getline() 时，需要注意的是，在cin>>读入数据完成后，如果接下来的字符是换行符，那么在使用getline()之前需要用getchar()把换行符吞掉，然后再使用getline()读入下一行数据。否则，getline()会首先读入换行符，然后停止读取。由于getline()函数会丢弃数据末尾的换行符，因此最终读入的数据为空。

 定义了三个类：istringstream、ostringstream 和 stringstream，分别用来进行流的输入、输出和输入输出操作。以 stringstream 为例，介绍流的输入和输出操作。

< sstream > 使用string对象来代替字符数组，这样可以避免缓冲区溢出的危险。而且，传入参数和目标对象的类型被自动推导出来，即便使用了不正确的格式化符也没有危险。

与文件流fstream类似，通过插入器(<<)和析取器(>>)这两个运算符可以直接对stringstream上的数据输入输出，而将stringstream中的全部数据输出则是使用成员函数str()，其有两种形式：
1、void str() //无参形式，用于将stringstream流中的数据以string字符串的形式输出
2、void str (const string& s)//以字符串为参数，用以覆盖stringstream流中的数据
特别需要注意的是：

// 字符串流清零，将流中的数据全部清除
ss.str(""); 

 更多字符串流stringstream与string知识可参考如下：C++字符串流stringstream与string知识介绍与用法小结

#include
#include
#include
#include
#include
#include   //INT_MIN 和 INT_MAX的头文件

二、一维整型数组的输入

1）在终端的一行中输入固定数目的整型数字，并存到数组中，中间以空格分隔

//方法1：固定大小为n   优先用方法1
int n;
cin>>n;
vector<int> nums(n);
for (int i=0;i
    cin>>nums[i];
}
//处理这组数
for(int i=0;i
    cout<
}
 
//方法2：vector数组未初始化大小时，只能用push_back方式插入数据
int n;
cin>>n;
vector<int> nums;
for(int i=0;i
    int val;
    cin>>val;
    nums.push_back(val);
}

2）在终端的一行中输入固定数目的整型数字，并存到数组中，中间以（其他单字符, . /）分隔

//int m;
cin>>m;
char sep;
vector<int> nums(m);
 
for(int i=0;i-1;++i)
{
    cin>>nums[i]>>sep;
}
cin>>nums[m-1];

3）在终端的一行中输入非固定数目的整型数字，并存到数组中，中间以空格（或者其他单字符 ， . /）分隔

//方法1：getchar
//代码通过cin.get()从缓存中读取一个字节，这样就扩充了cin只能用空格和TAB两个作为分隔符
//很精巧，发现是'\n'就知道一行结束了
vector<int> nums;
int num;
while(cin>>num){
    nums.push_back(num);
    if(getchar() == '\n')
        break;
}
 
//方法2：cin.get
vector<int> nums;
int num;
while(cin>>num){
    nums.push_back(num);
    if(cin.get() == '\n')
        break;
}

三、字符串的输入输出

1）给定一行字符串，每个字符串用空格间隔，一个样例为一行

示例：daa ma yello

法一：

int main(){
    string str;
    vector strs;
    while(cin>>str){
        strs.push_back(str);
        //注意getchar从缓冲区读取一个字符，能够读取空格、回车等,故输入的最后字符不要是空格
        //空格被getchar读取后，再输入回车,会出不了循环，等待下一次输入，这里只能'\n'出循环
        if (getchar()=='\n'){
            break;
        }
    }
 
    //排序
    sort(strs.begin(),strs.end());
 
    //遍历
    for (auto& str : strs) {
        cout << str << " ";
    }
 
    //清理
    strs.clear();
 
    return 0;
}

2）给定一行字符串，每个字符串间用逗号间隔，一个样例为一行

方法：使用getline读取一整行字符串到字符串input中，然后使用字符串流stringstream,读取单个数字或者字符，每个字符中间用','间隔

//对输入的字符串进行排序后输出
int main(){
    string input;
    while(getline(cin,input)){ //读取一行字符串
        vector strs;
        string str;
        stringstream ss(input);  //将input复制到ss
 
        //while(ss>>str)   相当于输入一个一个的str
        while(getline(ss,str,',')){       //
            strs.push_back(str);
        }
        sort(strs.begin(),strs.end());
        for(auto& str:strs){
            cout<" ";
        }
        cout<
    }
    return 0;
}

四、二维整型数组的输入输出

#include 
#include 
using namespace std;
 
int main()
{
	int r, c;
	cin >> r >> c;
	//定义二维数组
	vectorint>> array;
	//定义一维数组
	vector<int> v;
	int temp = 0;
	for (int i = 0; i < r; i++)
	{
		v.clear(); //子数组返回时要清除
		for (int j = 0; j < c; j++)
		{
			cin >> temp;
			v.push_back(temp);
		}
		array.push_back(v);
	}
	//遍历输出二维数组
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			cout << array[i][j] << " ";
		}
		printf("\n");
	}
	
	system("pause");
	
	return 0;
}
 
 

五、二维字符数组的输入输出

int n,m;
cin>>n>>m;        //n行m列
 
//输入
vectorchar>> data(n,vector<char>(m));  //二维数组
for(int i=0;i
    for(int j=0;j
        cin>>data[i][j]
    }
}
 
//输出
for(int i = 0;i < n; i++){
    for(int j = 0; j < m; j++){
        cout << data[i][j] << " ";
    }
    cout<
}

六、链表节点的定义

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

在链表类实现一些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
 
    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }
 
    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }
 
    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
 
    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
 
    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则置为0，作为链表的新头节点。
    void addAtIndex(int index, int val) {
        if (index > _size || index < 0) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
 
    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }
 
    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
 
};

七、二叉树的定义

二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，下面列出链式存储的二叉树节点的定义方式

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};