L'impression de la chaîne d'entrée des mots dans l'ordre inverse

Ici est un C-approche fondée sur les compiler avec un compilateur C++ qui utilise la pile à minimiser la création de char * cordes. Avec un minimum de travail, ce peut être adapté à des classes C++, ainsi que trivialement remplacer les différents for boucles avec un do-while ou while bloc.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINE_LENGTH 1000
#define MAX_WORD_LENGTH 80
void rev(char *str) 
{
size_t str_length = strlen(str);
int str_idx;
char word_buffer[MAX_WORD_LENGTH] = {0};
int word_buffer_idx = 0;
for (str_idx = str_length - 1; str_idx >= 0; str_idx--)
word_buffer[word_buffer_idx++] = str[str_idx];
memcpy(str, word_buffer, word_buffer_idx);
str[word_buffer_idx] = '\0';
}
int main(int argc, char **argv) 
{
char *line = NULL;
size_t line_length;
int line_idx;
char word_buffer[MAX_WORD_LENGTH] = {0};
int word_buffer_idx;
/* set up line buffer - we cast the result of malloc() because we're using C++ */
line = (char *) malloc (MAX_LINE_LENGTH + 1);
if (!line) {
fprintf(stderr, "ERROR: Could not allocate space for line buffer!\n");
return EXIT_FAILURE;
}
/* read in a line of characters from standard input */
getline(&line, &line_length, stdin);
/* replace newline with NUL character to correctly terminate 'line' */
for (line_idx = 0; line_idx < (int) line_length; line_idx++) {
if (line[line_idx] == '\n') {
line[line_idx] = '\0';
line_length = line_idx; 
break;
}
}
/* put the reverse of a word into a buffer, else print the reverse of the word buffer if we encounter a space */
for (line_idx = line_length - 1, word_buffer_idx = 0; line_idx >= -1; line_idx--) {
if (line_idx == -1) 
word_buffer[word_buffer_idx] = '\0', rev(word_buffer), fprintf(stdout, "%s\n", word_buffer);
else if (line[line_idx] == ' ')
word_buffer[word_buffer_idx] = '\0', rev(word_buffer), fprintf(stdout, "%s ", word_buffer), word_buffer_idx = 0;
else
word_buffer[word_buffer_idx++] = line[line_idx];
}
/* cleanup memory, to avoid leaks */
free(line);
return EXIT_SUCCESS;
}

Pour compiler avec un compilateur C++, et utiliser ensuite:

$ g++ -Wall test.c -o test
$ ./test
foo bar baz
baz bar foo

Il utilise exactement un chacun de if et while.

#include <string>
#include <iostream>
#include <sstream>
void backwards(std::istream& in, std::ostream& out)
{
std::string word;
if (in >> word)   //Read the frontmost word
{
backwards(in, out);  //Output the rest of the input backwards...
out << word << " ";  //... and output the frontmost word at the back
}
}
int main()
{
std::string line;
while (getline(std::cin, line))
{
std::istringstream input(line);
backwards(input, std::cout);
std::cout << std::endl;
}
}

Ce code ici utilise des bibliothèques de chaînes de caractères pour détecter les blancs dans le flux d'entrée et de réécrire la sortie de la phrase en conséquence

L'algorithme est
1. Obtenir le flux d'entrée à l'aide de getline fonction pour capturer le spacecs. Initialiser pos1 à zéro.
2. Cherchez le premier espace dans le flux d'entrée
3. Si aucun espace n'est trouvé, le flux d'entrée est la sortie
4. Autre chose, obtenir la position de la première vierge après pos1, c'est à dire pos2=.
5. Enregistrez le sous-chaîne entre pos1 et pos2 = au début de la sortie de la phrase; newSentence.
6. Pos1 est maintenant à la première char après le vide.
7. Répétez les 4, 5 et 6 jusqu'à pas d'espace à gauche.
8. Ajouter la dernière sous-chaîne de caractères au début de la newSentence. –

#include <iostream> 
#include <string> 
using namespace std; 
int main ()
{ 
string sentence; 
string newSentence;
string::size_type pos1; 
string::size_type pos2; 
string::size_type len; 
cout << "This sentence rewrites a sentence backward word by word\n"
"Hello world => world Hello"<<endl;
getline(cin, sentence); 
pos1 = 0; 
len = sentence.length();
pos2 = sentence.find(' ',pos1); 
while (pos2 != string::npos)
{
newSentence = sentence.substr(pos1, pos2-pos1+1) + newSentence; 
pos1 = pos2 + 1;
pos2 = sentence.find(' ',pos1);       
}
newSentence = sentence.substr(pos1, len-pos1+1) + " "  + newSentence;
cout << endl << newSentence  <<endl; 
return 0;
}