从标准输入读取一行数组并保存（用的是字符串分割函数strtok_s() ）

首先介绍字符串分割函数：

char *strtok_s(
char *strToken,   //字符串包含一个标记或一个以上的标记。
const char *strDelimit,  //分隔符的设置
   char **context   //用于存储调用 strtok_s 之间位置信息
); 

原来的函数strtok()因为具有线程不安全性，在linux内核中已被停止使用，需使用安全的strtok_s()。

The strtok_s function finds the next token instrToken. The set of characters in strDelimit specifies possible delimiters of the token to be found in strToken on the current call.

在第一次调用 strtok_s 函数跳过前导分隔符并返回指向在 strToken的第一个标记的指针，以空字符终止标记。 通过一系列 strtok_s 的调用，多个标记将被从 strToken 的其余部分拆开。 每个调用 strtok_s 通过插入 null 字符修改 strToken 在该返回的标记之后调用。 context 指针记录哪个字符串被读取，并记录将字符串下一个标记要读取的位置。 若要读取 strToken的下一个标记，请调用带有一个 strToken 参数的NULL 值的 strtok_s，并传递相同的 context 参数。 NULL  strToken 参数引起 strtok_s 搜索修改的 strToken的下一个标记。 strDelimit 参数可以接收一个调用到另一调用的任何值对，以便分隔符的设置可以更改。

因为 context 参数可用于 strtok 和 _strtok_l的静态缓冲区区域，同时在同一线程上分析两个字符串是可能的。（以上介绍来自MSDN库）

以msdn库的例子介绍：

// crt_strtok_s.c
// In this program, a loop uses strtok_s
// to print all the tokens (separated by commas
// or blanks) in two strings at the same time.
//

#include <string.h>
#include <stdio.h>

char string1[] =
    "A string\tof ,,tokens\nand some  more tokens";
char string2[] =
    "Another string\n\tparsed at the same time.";
char seps[]   = " ,\t\n";
char *token1 = NULL;
char *token2 = NULL;
char *next_token1 = NULL;  //content
char *next_token2 = NULL;   //content

int main( void )
{
    printf( "Tokens:\n" );

    // Establish string and get the first token:
    token1 = strtok_s( string1, seps, &next_token1);
    token2 = strtok_s ( string2, seps, &next_token2);

    // While there are tokens in "string1" or "string2"
    while ((token1 != NULL) || (token2 != NULL))
    {
        // Get next token:
        if (token1 != NULL)
        {
            printf( " %s\n", token1 );
            token1 = strtok_s( NULL, seps, &next_token1);
        }
        if (token2 != NULL)
        {
            printf("        %s\n", token2 );
            token2 = strtok_s (NULL, seps, &next_token2);
        }
    }
}

Output：

Tokens:
 A
        Another
 string
        string
 of
        parsed
 tokens
        at
 and
        the
 some
        same
 more
        time.
 tokens

此时可以处理从标准输入输入不定长的数组并保存的问题：

#include <iostream>
#include<string>
#include<string.h>
#include<vector>

using namespace std;

void Split_input(vector<int> &v1) {
    string s1;
    getline(cin, s1);
    cout << "s1 = " << s1 << endl;

    char* seps = " ";//空格，Note：可以是多个符号，只要待分割的字符串含有其中之一就可以分割
    char *token = NULL;
    char *next_token = NULL;

    char *buf = new char[strlen(s1.c_str()) + ];
    const char *tmp = s1.c_str();
    strcpy_s(buf, strlen(s1.c_str()) + ,tmp);//这两句是为了类型转换，因strtok_s 的实参必须是char*，而string类型转换为char* 类型结果为const char* 故指向const的指针不能被赋给指向非const的指针,所以应该用strcpy，也就是另开一块内存，把字符一个个复制过去

    token = strtok_s(buf, seps, &next_token);
    while (token != NULL)
    {
        if (token != NULL)
        {
            v1.push_back(atoi(token)); // 将char转换为数字存入v1
            token = strtok_s(NULL, seps, &next_token);
        }
    }
　　delete[] buf;
    vector<int>::size_type v1_count;
    for (v1_count = ; v1_count < v1.size(); ++v1_count)    //输出
    {
        cout << v1[v1_count] << " "<< endl;
    }
}

int main() {
    vector<int> vec;
    Split_input(vec);
    system("pause");
}

上面用的是字符串切割，若是输入的一行是纯数组，就不用那么麻烦，其实这才是我最初想要的，ののの，就这样吧：

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    int i;
    vector<vector <int>> v;
    vector<int> v1;
    for (int j = ; j < ;++j)
    {
        v1.clear();//vector的clear()并不能删除内存，可用vector<int>(v1).swap(v1);原理是将大capacity置换为小的capacity
        do
        {
            cin >> i;
            v1.push_back(i);
        } while (cin.get() != '\n');
        v.push_back(v1);
    }

    for (int j = ; j < ;++j) {   //输出
        int tmp;
        for (tmp = ; tmp < v[j].size();++tmp)
        {
            cout << v[j][tmp] << endl;
        }
        cout << "\n" << endl;
    }
}