web-dev-qa-db-fra.com

Comment lire n entiers d'entrée standard en C ++?

J'ai besoin de lire quelque chose comme:

5 60 35 42
2 38 6
5 8
300 1500 900

Puis enregistrez la première ligne dans un tableau. Après avoir appelé d'autres fonctions, faites de même avec la ligne suivante, etc.

J'essaie avec gets(), puis utilisez sscanf() pour numériser les entiers de la chaîne, mais je ne sais pas comment lire n chiffres d'une chaîne.

c++stdin
13
Topo

J'ai vu des fichiers d'entrée comme celui-ci pour les compétitions avant. Si la vitesse est plus d'un problème que la détection d'erreur, vous pouvez utiliser une routine personnalisée. Voici une similaire à celle que j'utilise:

void readintline(unsigned int* array, int* size) {
    char buffer[101];
    size=0;
    char* in=buffer;
    unsigned int* out=array;
    fgets(buffer, 100, stdin);
    do {
        *out=0;
        while(*in>='0') {
            *out= *out* 10 + *in-'0';
            ++in;
        }
        if (*in)
            ++in; //skip whitespace
        ++out;
    } while(*in);
    size = out-array;
}

Il détruira votre mémoire s'il y a plus de 100 caractères sur une ligne, ou plus de numéros que la matrice ne peut contenir, mais vous n'obtiendrez pas une routine plus rapide pour lire dans des lignes d'INTS non signé.

D'autre part, si vous voulez simple:

int main() {
    std::string tmp;
    while(std::getline(std::cin, tmp)) {
        std::vector<int> nums;
        std::stringstream ss(tmp);
        int ti;
        while(ss >> ti) 
            nums.Push_back(ti);
        //do stuff with nums
    }
    return 0;
}
9
Mooing Duck

C++

Si vous avez un nombre inconnu d'entrées réparties sur un nombre inconnu de lignes, se terminant à EOF:

int n;
while(cin >> n)
  vector_of_int.Push_back(n);

Si vous avez un nombre connu d'entrées réparties sur un nombre inconnu de lignes:

int n;
int number_of_entries = 20; // 20 for example, I don't know how many you have.
for(int i ; i < number_of_entries; ++i)
  if(cin >> n)
    vector_of_int.Push_back(n);

Si vous avez un numéro connu d'entrées sur une seule ligne:

std::string str;
std::getline(std::cin, str);
std::istringstream sstr(str);
int n;
while(sstr >> n)
  vector_of_int.Push_back(n);

Si vous avez un nombre inconnu d'entrées réparties sur un nombre connu de lignes:

for(int i = 0; i < number_of_lines; ++i) {
  std::string str;
  if(std::getline(std::cin, str)) {
    std::istringstream sstr(str);
    int n;
    while(sstr >> n)
      vector_of_int.Push_back(n);
  }
}
25
Robᵩ

J'écrirais probablement le code quelque chose comme ceci:

// Warning: untested code.
std::vector<int> read_line_ints(std::istream &is) { 
    std::string temp;
    std::getline(is, temp);

    std::istringstream buffer(temp);
    int num;
    std::vector<int> ret;

    while (buffer>>num)
        ret.Push_back(num);
    return ret;
}
4
Jerry Coffin

En C++, vous pouvez utiliser std::istringstream.

std::string nums = "1 20 300 4000";
std::istringstream stream(nums);
int a, b, c, d;
stream >> a >> b >> c >> d;
assert(a == 1 && b == 20 && c == 300 && d == 4000);

Si vous souhaitez l'obtenir de l'entrée standard, faites la même chose, mais utilisez simplement std::cin

std::cin >> a >> b >> c >> d;
3
Peter Alexander

La solution rapide est de les lire avec scanf()

int array[1000];
int index = 0;

while ((index < 1000) && (scanf("%d", &tmp) == 1)) {
    array[index++] = tmp;
}

Cela a toujours besoin d'un peu plus de validation ...

3
pmg

C++:

vector<int> ints;
while( !cin.eof() )
{
   int t;
   cin >> t;
   if ( !cin.eof() )
      ints.Push_back(t);
}

Alternative (Thx à Shahbaz)

int t;
vector<int> ints;
while(cin >> t)
   ints.Push_back(t);
2
George Kastrinis

En C++, il est extrêmement simple de lire N entiers séparés par WhitSpace via STDIN:

#include <iostream>

using namespace std;

const unsigned N = 5;

int main(void)
{
   int nums[N];

   for (unsigned i = 0; i < N; ++i)
      cin >> nums[i];

   cout << "Your numbers were:\n";

   for (unsigned i = 0; i < N; ++i)
      cout << nums[i] << " ";

   cout << "\n";

   return 0;
}
0
AusCBloke