只需在输入行上使用一个循环，利用 atol() 无论如何都会在下一个空格分隔符处停止。仅适用于正整数；）但它很快，您无需阅读大量的 strtok 和 sscanf 文档，并且在整数之间散布“噪音”的情况下它甚至是健壮的。
要使其也适用于负整数，请将 isdigit() 替换为 !isspace() 即可。
void bla()
{
const char * input = " 1 3 4 6 ";
size_t i;
size_t len = strlen(input);
for (i = 0; i < len; ++i)
{
if (isdigit(input[i]))
{
printf("%d\n", atol(&input[i]));
while (i < len && isdigit(input[i]))
++i;
}
}
}
void bla1()
{ // positive and negative ints version
const char * input = " 10 -3 42 6 ";
size_t i;
size_t len = strlen(input);
for (i = 0; i < len; ++i)
{
if (!isspace(input[i]))
{
printf("%d\n", atol(&input[i]));
while (i < len && !isspace(input[i]))
++i;
}
}
/* Output:
10
-3
42
6
*/
}
您的问题的下一部分是（隐含地），如何处理动态数组以将解析的 int 值存储在其中。这里是基于上述代码的解决方案。对于输入，chunkSize 设置得太小，所以我可以测试 realloc 代码部分是否也有效。
typedef struct DataRow_tag
{
int32_t *data;
size_t length;
} DataRow_t;
// Returns a "bool" in C-style. Yes, there is stdbool.h in ansi c99 but it is disadviced.
// (Platform dependent trouble in the context of C/C++ interaction, often across library/DLL boundaries.
// Especially if you compile C with a C-compiler and the C++ code with C++ compiler. Which happens.
// Every now and then, sizeof(c++ bool) != sizeof(C bool) and you waste a lot of time finding the problem.)
// The caller takes ownership of the DataRow_t::data pointer and has to free() it when done using it.
// 0: false -> fail
// 1: true -> success!
int
ReadRowWithUnknownNumberOfColumnsOfInt32
( const char * row // Zero terminated string containing 1 row worth of data.
, DataRow_t *result // Pointer to the place the data will be stored at.
)
{
int success = 0;
size_t chunkSize = 10; // Set this value to something most likely large enough for your application.
// This function is not cleaning up your garbage, dude ;) Gimme a clean result structure!
assert(NULL != result && NULL == result->data);
if (NULL != result && NULL == result->data)
{
result->length = 0;
size_t rowLength = strlen(row);
const char *pInput = row;
const char *pEnd = &row[rowLength-1];
result->data = (int32_t*)malloc(chunkSize * sizeof(int32_t));
if (NULL != result->data )
{
for (; pInput < pEnd; ++pInput)
{
assert(pInput <= pEnd);
assert(*pInput != 0);
if (!isspace(*pInput)) // ultra correct would be to cast to unsigned char first...says microsoft code analyzer in paranoia mode.
{
long lval = atol(pInput); // what is a long anyway? 4 bytes, 2 bytes, 8 bytes? We only hope it will fit into our int32_t...
// TODO: we could test here if lval value fits in an int32_t...platform dependent!
result->data[result->length++] = lval;
if (result->length == chunkSize)
{ // our buffer was too small... we need a bigger one.
chunkSize = chunkSize + chunkSize; // doubling our buffer, hoping it will be enough, now.
int32_t * temp = (int32_t*)realloc(result->data, chunkSize * sizeof(int32_t));
if (NULL == temp)
{ // realloc is a funny function from the dark ages of c. It returns NULL if out of memory.
// So we cannot simply use result->data pointer for realloc call as this might end up with a memory leak.
free(result->data);
result->length = 0;
break;
}
else
{
result->data = temp;
}
}
while (pInput < pEnd && !isspace(*pInput))
++pInput;
}
}
if (pInput >= pEnd)
success = 1;
else
{ // make sure we do not leave result in some funny state.
result->length = 0;
free(result->data); // free(NULL) legal. If memblock is NULL, the pointer is ignored and free immediately returns.
result->data = NULL;
}
}
}
return success;
}
void Bla2()
{
const char * input = "-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13";
DataRow_t dataRow = { 0 };
if (ReadRowWithUnknownNumberOfColumnsOfInt32(input, &dataRow))
{
for (size_t i = 0; i < dataRow.length; ++i)
{
printf("%d ", dataRow.data[i]);
}
printf("\n");
free(dataRow.data);
dataRow.data = NULL;
dataRow.length = 0;
}
}