没有 output，我的代码有什么问题？

Question

I am trying to store the reverse of a text stored in (x) in another variable (y), but there is no output!

#include <iostream>
#include <string>
using namespace std;
int main() { 
    int i=0, j=0;
    string x,y;
    cin>> x;
    for (char c: x) i++;
    for (int j=0; j<i; j=j+1)
        y[j]=x[i-j-1];
    cout <<y;
return 0;
}

Answer 1

What do you think the size of y is?

You never change it's size, so the size stays at zero and this code

y[j]=x[i-j-1];

is an error because you cannot use [] on a string that has size zero. Using [] on a string never changes it's size, and it's an error to use [] with an index that doesn't exist for the string.

Try this instead

for (int j=0; j<i; j=j+1)
    y.push_back(x[i-j-1]);

push_back adds a character to the end of a string, increasing the size of the string by one.

BTW an easier way to write this code

i = 0;
for (char c: x) i++;

is

i = x.size();

strings have a size method that tells you what their size is.

Answer 2

You also could use reverse iterators rbegin/crbegin and rend/crend :

#include <iostream>
#include <string>
using namespace std;
int main() { 
    string x,y;
    cin>> x;
    std::copy(x.crbegin(), x.crend(), std::back_inserter(y));
    cout <<y;
    return 0;
}

Answer 3

You did not allocated the memory for y, when you use y[j], actually it doesn't exist, you should resize y, just add the following code after the first for loop

y.resize(i);

Anyway is easier using member and methods of class strig, this is a link with a complete list of them and explanations http://www.cplusplus.com/reference/string/string/

using those, your code will look like the following

#include<iostream>
#include<string>
using namespace std;
int main() {
    string x, y;
    cin>>x;;
    for(string::reverse_iterator it=x.rbegin(); it!=x.rend(); it++) {
        y.push_back(*it);
    }
    cout<<y;
} 

iterators are object which you can use for handling containers like the string s, they act as pointers, in this example I used reverse_iterators which are exaclty the same, but they iterate from the last element to the first one.