Simply print the string backwards

Question

This code is very, very simple, but I was wondering how it could be improved:

#include <iostream>

int main() {
    std::string input;
    std::getline(std::cin, input);

    for(int i = 1; i <= input.length(); i++){
        std::cout << input[input.length() - i];
    }

    std::cout << '\n';
    return 0;
}

This code takes a string input, and prints it backwards. For example:

This will be printed backwards.

Becomes:

.sdrawkcab detnirp eb lliw sihT

Given the simplicity of this code, is there a way to optimize it? I understand that since it is very short, it will run fast no matter what. However, I hate inefficiencies in code, and I want to help improve the way that I write code.

This is related to, but not copied directly from, this SO answer. (I only found this SO answer after writing the code)

Answer 1

One simple improvement would be to restructure the for() loop:

for(int i = input.length() - 1; i >= 0; --i){
    std::cout << input[i];
}

A simple decrement operation might lead to more efficient machine code than calculating input.length() - i in every iteration.

---

Another improvement would be to use a more c++-ish way. But that means to change the string itself:

 std::getline(std::cin,input);
 std::reverse(std::begin(input),std::end(input));
 std::cout << input << '\n';

---

Or using the reverse iterators in the loop:

 for(auto it = input.rbegin(); it != input.rend(); ++it) {
      std::cout << *it;
 }

---

As I've mentioned in my comment, the most generic (and c++stylish) way to achieve that is to write your own adapter to achieve iterating a sequence in the reverse order. So I'm citing that solution here:

 // -------------------------------------------------------------------
 // --- Reversed iterable
 using namespace std; // for rbegin() and rend()

 template <typename T>
 struct reversion_wrapper { T& iterable; };

 template <typename T>
 auto begin (reversion_wrapper<T> w) { return rbegin(w.iterable); }

 template <typename T>
 auto end (reversion_wrapper<T> w) { return rend(w.iterable); }

 template <typename T>
 reversion_wrapper<T> reverse (T&& iterable) { return { iterable }; }

Above taken from here.

Answer 2

another way:

#include <iostream>
#include <iterator>
#include <algorithm>

int main() {
    std::string input;
    std::getline(std::cin, input);
    std::copy(input.rbegin(), input.rend(), 
              std::ostream_iterator<char>(std::cout));

    std::cout << '\n';
    return 0;
}

If I were going to do this often, I'd be tempted to make a little library extension:

#include <iostream>
#include <iterator>
#include <algorithm>
#include <string>

namespace notstd {
    template<class Iter>
    struct reverser
    {
        using value_type = typename std::iterator_traits<Iter>::value_type;

        template<class Ch, class Traits>
        std::basic_ostream<Ch, Traits>& 
        operator ()(std::basic_ostream<Ch, Traits>& os) const
        {
            std::copy(first, last, 
                      std::ostream_iterator<value_type, Ch, Traits>(os));
            return os;
        }

        Iter first, last;

        template<class Ch, class Traits>
        friend std::basic_ostream<Ch, Traits>& 
        operator <<(std::basic_ostream<Ch, Traits>& os, reverser eng)
        {
            return eng(os);
        }
    };

    template<class Iter>
    auto make_reverser(Iter first, Iter last)
    {
        return reverser<Iter> {first, last};
    }

    template<class Iter,
        std::enable_if_t<std::is_same<std::remove_cv_t<typename std::iterator_traits<Iter>::value_type>, char>::value>* = nullptr
    >
    auto to_string(const reverser<Iter>& eng)
    {
        return std::string(eng.first, eng.last);
    }

    template<class Iter,
        std::enable_if_t<std::is_same<std::remove_cv_t<typename std::iterator_traits<Iter>::value_type>, wchar_t>::value>* = nullptr
    >
    auto to_string(const reverser<Iter>& eng)
    {
        return std::wstring(eng.first, eng.last);
    }

    template<class Range>
    auto reversed(Range&& range)
    {
        return make_reverser(std::rbegin(range), std::rend(range));
    }

    template<class Elem, std::size_t N,
        std::enable_if_t<
            std::is_same<char, std::remove_cv_t<Elem>>::value or
            std::is_same<wchar_t, std::remove_cv_t<Elem>>::value
        > * = nullptr
    >
    auto reversed(Elem (& range)[N])
    {
        static_assert(N > 0, "");
        return make_reverser(std::rbegin(range) + 1,
                             std::rend(range));
    }
}

int main(int argc, char **argv)
{
    std::string input = argv[0];
//    std::getline(std::cin, input);

    std::cout << notstd::reversed(input) << '\n';
    std::cout << notstd::reversed("Hello") << std::endl;
    std::wcout << notstd::reversed(L"World") << std::endl;

    std::cout << to_string(notstd::reversed("baloney")) << std::endl;
    std::wcout << to_string(notstd::reversed(L"wide baloney")) << std::endl;

    return 0;
}

example output:

don/gubed-dliub-ekamc/tcejorp/yalp/segdohr/sresU/
olleH
dlroW
yenolab
yenolab ediw

Answer 3

You can construct a string from a pair of iterators, so it seems to me that the method that's probably simplest is something on this order:

std::string my_string = "Hello, World!";

std::cout << std::string(my_string.rbegin(), my_string.rend()) << '\n';

Return from main

I'd also eliminate the return 0; from main. If you don't specify otherwise, main returns 0 by default.

#include what you use

Your code uses std::string, so it should #include <string> to make it available.

Answer 4

To print any container that supports bidirectional iterators, which include not only plain ascii strings but also unicode strings, vectors, dequeues ...

// somecode.h
#include <utility>

template<typename Cont>
void print_bidir_cont(Cont& cont) noexcept(noexcept(std::cout))
{
    auto lside{ c.rbegin() };
    auto rside{ c.rend() };
    while( lside < rside) std::cout << *lside++;
}

then use it like:

// main.cpp
#include "somecode.h"
#include <string>
#include <iostream>
#include <vector>

int main()
{
    std::cout << "Please enter the string to revert: ";
    std::string s;
    std::cin >> s;
    std::cout << std::endl;

    print_bidir_cont(s);

    std::cout << std::endl;

    // ...

    std::vector<double> v{ 1.0, 2.0, 3.0, 4.0 };
    std::cout << "Reverting a vector too:";
    print_bidir_cont(v);

    std::cout << std::endl; 

    return 0;
}

...yet I still ask myself why do some have their strings stored backwards.

Answer 5

Using a simple reverse iterator is probably the simplest and most effective way of improving your code:

std::string my_string = "Hello World!";

for(auto IT = my_string.rbegin(); IT != my_string.rend(); IT++)
{
  std::cout<<*IT<<std::endl;
}

I would avoid ostreams as 1) over complicates a very simple operation and 2) std::cout fits you problem.

Answer 6

You could use the XOR swap algorithm: https://en.wikipedia.org/wiki/XOR_swap_algorithm

#include <iostream>
#include <string>

using namespace std;

string revStr(string str)
{
    int end= str.length() - 1;
    int start = 0;

    while(start < end)
    {
        str[start] ^= str[end];
        str[end]   ^= str[start];
        str[start] ^= str[end];

        ++start;
        --end;
    }

    return str;
}

int main() 
{
    cout << revStr("Test");

    return 0;
}