Why is string.length()=0 after processing string using string[i]?

Question

I made a program in C++ to take a sentence as input and wanted display the sentence after omitting the spaces , however I'm getting weird results ... s2 is the string containing the sentence after omitting spaces. I can access the string s2 as s2[i] , but I'm getting no output when I try cout<< s2; and value of s2.length() gets printed as 0 ??

#include<iostream>
using namespace std;
int main()
{
    string s1,s2;
    int i,j,l1,l2;
    getline(cin,s1);
    l1=s1.length();
    j=0;
    for(i=0;i<l1;i++)
    {
        if(s1[i]!=' ')
        {
            s2[j]=s1[i];
            j++;
        }
    }
    cout<<s2.length();
    cout<<s2<<endl;
}

Expected : s2.length() shouldn't be 0 and cout<< s2; should work.

Good read: https://en.cppreference.com/w/cpp/string/basic_string/operator_at — NathanOliver, Jan 14 '19 at 16:31
Please don't tag with unrelated tags. This is, clearly, not C. — Algirdas Preidžius, Jan 14 '19 at 16:32
Try and get out of the habit of `using namespace std`. That prefix is there for a reason: To protect you from naming collisions and to make it clear where those functions, data structures and other things come from. — tadman, Jan 14 '19 at 16:33
`string s1,s2;` now you have a string `s2` with length 0, and after that you never change its length... — 463035818_is_not_an_ai, Jan 14 '19 at 16:33
`s2[j]` is undefined behavior, with any value of `j`, if `s2` is empty. — Algirdas Preidžius, Jan 14 '19 at 16:34
`operator[]` does not grow the string if you go beyond the bounds. You must set the size yourself in some way before accessing those elements. — François Andrieux, Jan 14 '19 at 16:35
[Here: read a good C++ book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list), it will teach you how `std::string` works and other important topics. — Blastfurnace, Jan 14 '19 at 16:35
I don't understand the downvotes. The question clearly explains the problem and presents an reproducible example. IMHO, it is a reasonable question even if one has read a c++ book. — balki, Jan 14 '19 at 17:44

score 3 · Answer 1 · edited Jan 14 '19 at 17:13

s2[j]=s1[i];

s2 is initially empty. Accessing s2[j] is out of bounds and undefined behavior.

Change it to s2+=s1[i] and all is good.

Update FYI, in mordern C++ you don't usually need to deal with lengths because you should prefer using standard library algorithms:

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

int main()
{
    std::string s1,s2;
    getline(std::cin,s1);
    std::copy_if(s1.begin(), s1.end(), std::back_inserter(s2), [](char ch){
        return ch!=' ';
    });
    std::cout<<s2.length();
    std::cout<<s2<<'\n';
}

score 2 · Answer 2 · answered Jan 14 '19 at 16:39

2

The length of a default-constructed string is 0.

s2[j] accesses the character at the index j. If that character doesn't exist, then the behaviour of the program is undefined.

When the length of the string is 0, for any j greater than 0, s2[j] has undefined behaviour, because that character doesn't exist. s2[0] is well defined and refers to the null terminator.

You may have intended to add characters to the string. You can add characters to a string for example using the push_back member function or += operator.

answered Jan 14 '19 at 16:39

eerorika

232,697
12
197
326

"s2[0] is well defined and refers to the null terminator." really? has this always been the case? – 463035818_is_not_an_ai Jan 14 '19 at 16:42
i got used to the fact that I will never stop learning c++, but its a bit intimidating that strings can still be a big surprise to me ;) – 463035818_is_not_an_ai Jan 14 '19 at 16:44
the behaviour was present already before c++11, it only changed to be more consistent between the two overloads (details [here](https://en.cppreference.com/w/cpp/string/basic_string/operator_at)) – 463035818_is_not_an_ai Jan 14 '19 at 16:46
@user463035818 oh, so it is. Only the non-const one was UB. I must have mixed up with the other guarantee that was added in C++11, which is that the buffer is null terminated even without `c_str`. – eerorika Jan 14 '19 at 16:50
Huh, I didn't know that either. – Lightness Races in Orbit Jan 14 '19 at 17:28

Jeffrey · Answer 3 · 2019-01-14T16:45:55.140

0

You cannot use [] to increase the s2 string size. If you use resize to grow it beforehand, it should work:

        s2.resize(j+1);
        s2[j]=s1[i];
        j++;

push_back() of a character on a std::string would do the same. However, I offer you this answer as it keeps the character assignment you already had. Philosophy of minimal answer/change :-).

edited Jan 14 '19 at 16:45

answered Jan 14 '19 at 16:37

Jeffrey

11,063
1
21
42

1

It may be worth mentioning that is, in principal, what `push_back` does. – François Andrieux Jan 14 '19 at 16:38

jim · Answer 4 · 2019-01-14T16:39:42.087

-1

#include<iostream>
using namespace std;
int main()
{
    string s1,s2;
    int i,l1;
    getline(cin,s1);
    l1=s1.length();
    for(i=0;i<l1;i++)
    {
        if(s1[i]!=' ')
        {
            s2.push_back(s1[i]); //CHANGE MADE HERE
        }
    }
    cout<<s2.length();
    cout<<s2<<endl;
}

As @iBug mentioned you can also use push_back as shown above

edited Jan 14 '19 at 16:39

answered Jan 14 '19 at 16:37

jim

1,026
2
15
37

Why is string.length()=0 after processing string using string[i]?

4 Answers4