c ++ affichage des phrases dans l’ordre inverse en utilisant des pointeurs

J’essaie de construire un programme qui prend des phrases courtes de l’utilisateur et les affiche dans l’ordre inverse. Malheureusement, je viens de commencer c ++, j’ai besoin de savoir pour le faire. par exemple: si l’utilisateur a entré l’entrée:

I like the red color blue is also nice and green is lovely but I don't like orange 

sortie:

 but I don't like orange and green is lovely blue is also nice I like the red color 

Merci d’avance!

 #include #include using namespace std; const int SIZE= 500; int main() { const int SIZE = 500; char myssortingng[SIZE]; int i; for(i=0; i<SIZE; i++) { cout<<"Enter a string: "; cin.getline(mystring, SIZE); } while (mystring != 0); char * reverse= new char[strlen(mystring) + 1]; char *p1 = mystring+ strlen(mystring); char *p2 = reverse; while(p1 != mystring) { p1--; *p2= *p1; p2++; } *p2 = '\0'; cout << reverse<<endl; system("PAUSE"); return 0; } 

L’un des moyens que vous souhaitez aborder est l’algorithme suivant:

  1. Chargez le fichier dans un tampon en le terminant par un caractère nul.
  2. Placez un pointeur p sur l’emplacement du dernier emplacement de mémoire tampon.
  3. Tandis que p ne pointe pas vers le début du tampon, procédez comme suit:
    • Si le caractère est une nouvelle ligne ( '\n' ), alors
      1. Envoyez la chaîne au- delà de la nouvelle ligne ( p+1 ) vers stdout.
      2. Remplacez la nouvelle ligne pointée par p par un caractère nul.
    • Décrémente p une position de caractère.
  4. Une fois la boucle ci-dessus terminée, il rest une ligne: la première. envoyez-le à stdout et vous avez terminé.

Ou alors je suis amené à croire. Les points importants à considérer sont les suivants:

  1. L’algorithme fonctionne-t-il avec un fichier vide?
  2. L’algorithme fonctionne-t-il avec un fichier contenant UNIQUEMENT des retours à la ligne?
  3. L’algorithme fonctionne-t-il avec un fichier multiligne SANS AUCUN saut de ligne?
  4. L’algorithme fonctionne-t-il avec un fichier à une seule ligne SANS AUCUNE nouvelle ligne?
  5. L’algorithme fonctionne-t-il avec un fichier multiligne AVEC une nouvelle ligne?
  6. L’algorithme fonctionne-t-il avec un fichier à une seule ligne, suivi d’une nouvelle ligne?

Ceci étant dit, voici un candidat potentiel:

 #include  #include  #include  #include  using namespace std; int main(int argc, char *argv[]) { // assume the file to reverse-print is the first // command-line parameter. if we don't have one // we need to leave now. if (argc < 2) return EXIT_FAILURE; // will hold our file data std::vector data; // open file, turning off white-space skipping ifstream inf(argv[1]); inf.seekg(0, inf.end); size_t len = inf.tellg(); inf.seekg(0, inf.beg); // resize buffer to hold (len+1) chars data.resize(len+1); inf.read(&data[0], len); data[len] = 0; // terminator // walk the buffer backwards. at each newline, send // everything *past* it to stdout, then overwrite the // newline char with a nullchar (0), and continue on. char *start = &data[0]; char *p = start + (data.size()-1); for (;p != start; --p) { if (*p == '\n') { if (*(p+1)) cout << (p+1) << endl; *p = 0; } } // last line (the first line) cout << p << endl; return EXIT_SUCCESS; } 

Consortingbution

 I like the red color blue is also nice and green is lovely but I don't like orange 

Sortie

 but I don't like orange and green is lovely blue is also nice I like the red color 

Une approche considérablement plus simple

Il existe des moyens beaucoup plus simples de le faire, et j'expliquerai chaque étape du commentaire en cours de route. La chance est que vous ne pouvez pas utiliser quelque chose comme ça, mais il est important que vous compreniez ce qui est disponible pour vous quand vous le pouvez :

 #include  #include  #include  #include  using namespace std; int main(int argc, char *argv[]) { // assume the file to reverse-print is the first // command-line parameter. if we don't have one // we need to leave now. if (argc < 2) return EXIT_FAILURE; // collection that will hold our lines of text vector lines; // read lines one at a time until none are returned // pushing each line in to our vector. ifstream inf(argv[1]); ssortingng line; while (getline(inf, line)) lines.push_back(line); inf.close(); // a LOT happens in the next single line of code, and // I will try to describe each step along the way. // // we use std::copy() to copy all "items" from // a beginning and ending iterator pair. the // target of the copy is another iterator. // // our target iterator for our formatted ouput // is a special iterator class designed to // perform an output-stream insertion operation // (thats the << operator) to the stream it is // constructed with (in our case cout) using each // item we give it from our copy-iteration. to use // this class the "copied" item must support the // traditional insertion operator <<, which of // course, std::string does. after each item is // written, the provided suffix (in our case \n) // is written as well. without this all the lines // would be ganged together. // // lastly, to glue this together (and the whole // reason we're here), we use a pair of special // iterators designed to work just like the regular // begin() and end() iterators you're familiar with, // when traversing forward in a sequence, but these // ones, rbegin() and rend(), move from the last // item in the sequence to the first item, which is // *exactly* what we need. copy(lines.rbegin(), lines.rend(), ostream_iterator(cout, "\n")); // and thats it. return EXIT_SUCCESS; } 

Consortingbution

 I like the red color blue is also nice and green is lovely but I don't like orange 

Sortie

 but I don't like orange and green is lovely blue is also nice I like the red color 

UPDATE: Intégration de la saisie utilisateur

Un exemple d'intégration de la saisie de l'utilisateur pour la deuxième version serait:

 #include  #include  #include  using namespace std; int main(int argc, char *argv[]) { // collection that will hold our lines of text vector lines; do { // prompt the user cout << "Sentance ( to exit): "; ssortingng line; if (!getline(cin, line) || line.empty()) break; lines.push_back(line); } while (true); // send back to output using reverse iterators // to switch line order. copy(lines.rbegin(), lines.rend(), ostream_iterator(cout, "\n")); return EXIT_SUCCESS; } 

Peut-être quelque chose comme:

 #include  #include  #include  using namespace std; // include headers and avoid having to use std:: all the time int main(){ vector data; ssortingng line; do{ std::getline(std::cin, line); data.push_back( line ); }while( cin );//read lines and store to a vector for (int i=data.size()-1;i>=0;--i)// traverse the vector in a reversed order (maybe size_t for i would be better) cout< 

On dirait que ce sont des devoirs et que vous êtes probablement limité à certaines fonctionnalités. Si vous insistez, nous pouvons écrire une version sécurisée pour les devoirs :

 // this is just intended to illustrate how RIDICULOUS it is not to use STL features. #include  #include  #include  int main(){ #define MAXLEN (10000) char* buffer = (char*)malloc(MAXLEN);//allocate space from heap char* buffer_ptr = buffer + 1; *buffer = '\0';//ssortingng terminator while( fgets(buffer_ptr,buffer+MAXLEN-buffer_ptr , stdin ) ){ buffer_ptr += strlen(buffer_ptr); ++buffer_ptr;// reserve the '\0' } buffer_ptr -= 2; while(buffer_ptr >= buffer){ if (!*buffer_ptr)// find end of ssortingng fputs(buffer_ptr+1,stdout); --buffer_ptr;// traverse backward } free(buffer);//free space } 

qui évite l'extension C ++ chaque fois que possible. (D'une manière peut-être ridicule)

 #include using namespace std; int main(){ char str[100][100]; for(int i =0; i < 10 ; i++) { cin.getline(str[i],100); } for(int i = 9 ; i >=0 ; i--) { cout< 

Voici comment le faire joli.

 template struct range_t { It b; It e; It begin() const { return b; } It end() const { return e; } }; template range_t range(It s, It f) { return {s,f}; } 

range( start, finish ) est une aide qui vous permet de créer une plage pouvant être utilisée for(:) itéré.

 template auto backwards(C&& c) { using std::rbegin; using std::rend; return range( rbegin(c), rend(c) ); } 

backwards(container) renvoie une plage qui parcourt le conteneur en arrière.

Une fois que nous avons écrit le code de bibliothèque ci-dessus, tout le travail est fait. Le code restant se lit presque aussi beau que python :

 int main() { std::cout << "Enter some text (blank line to finish):\n"; std::string line; std::vector lines; while (std::getline(std::cin, line)) lines.push_back(line); for (auto&& line:backwards(lines)) std::cout << line << "\n"; } 

Nous obtenons des lignes, les tampons, puis les imprimons à l'envers.

Exemple en direct .

Le but ici est de rendre la logique du programme principale aussi claire que possible. Le passe- backwards pour l’ backwards et l’ range ne fait que répondre à ce besoin.