Thread: please explain me the different behaviours related to toupper/string

in this 1st code t[0] return 'char' so the compiler throws an error illegal conversion from 'char' to 'const char*' :

Code:

//CODE 1

#include<iostream>              
#include<vector>
#include<cctype>
#include<string>


using namespace std;


int main()
{
        string t="hello";
/* If I had used 'toupper([0])' for direct initialization of string 's', it would have thrown error -> illegal conversion from int to const char* */
        string s(t[0]);
        return 0;
}

but in the second code I have used a vector of string type which I have changed from lower case to upper:

Code:

//CODE 2
#include<iostream>
#include<vector>
#include<cctype>
#include<string>


using namespace std;


int main()
{
        vector<string> vec(1,"hello");
        for(vector<string>::size_type j=0;j<vec[0].size();j++)
        {
                vec[0][j]=toupper(vec[0][j]);
        }
        cout<<vec[0]<<endl;
        return 0;
}

this 2nd code is accepting 'int' returned by toupper and vector of string type is accepting it without any error why this dual behavior?

Or is it due to the int-to-char natural/automatic conversion is taking place due to vec[0][j] indicating a 'char'?

The error message when I use toupper(t[0]) is:

k.cpp:11:23: error: invalid conversion from ‘int’ to ‘const char*’ [-fpermissive] string s(toupper(t[0]));

without using it, it is:

k.cpp: In function ‘int main()’:k.cpp:11:15: error: invalid conversion from ‘char’ to ‘const char*’ [-fpermissive]
string s(t[0]);

I think you mean
string t = "hello";
t[0] = toupper(t[0]);

Maybe if I knew what you were really doing there would be more to this.

nope, I am doing exactly what I have done, i.e. direct initialization of string 's' in code 1 and conversion to upper case in code 2.

Well, string does not have a constructor that is just one char argument, so statements like this will always fail for one reason or another.
string s(toupper(t[0]));

If you want string s to be Hello, I recommend modifying t and then simply doing
string s = t;

Well, string does not have a constructor that is just one char argument, so statements like this will always fail for one reason or another.
string s(toupper(t[0]));

the point of issue is: in code 1 the integer returned by toupper is rejected for initialization and in code 2 it is accepted -> in both the cases strings are involved.

maybe this clears better (from CODE 2):

is it due to the int-to-char natural/automatic conversion is taking place due to vec[0][j] indicating a 'char'?

You're thinking the wrong way about code 2 in general. Initialization is not even being used in code 2. What happens is vec[0] is a reference to a string in the array and then [j] acts upon that reference, so, you access character j of string 0 in vec.

OP: the version of toupper you're using returns an int: http://www.cplusplus.com/reference/cctype/toupper/for what you're trying to do use the one that uses std::locale: http://www.cplusplus.com/reference/locale/toupper/

Originally Posted by sean_cantab

OP: the version of toupper you're using returns an int: 404 Page Not Found what you're trying to do use the one that uses std::locale: http://www.cplusplus.com/reference/locale/toupper/

Well, other than being locale-aware, it doesn't solve the problem he had.

from OP:

Code:

 string s(t[0]);

understood this as OP wanted a single letter string which was == "H" if s/he'd been successful with the toupper() interim conversion. so this could be one solution:

Code:

#include <iostream>
#include <string>
#include <locale>


int main()
{
    std::locale loc{};
    std::string t = "HelloWorld";
    std::string s (1, (std::toupper(t[0], loc)));
    std::cout << s << "\n";
}

but yes, of course, this could be done with the non-locale version of toupper as well:

Code:

#include <iostream>
#include <string>
#include <cctype>


int main()
{
    std::string t = "HelloWorld";
    std::string s (1, (std::toupper(t[0])));
    std::cout << s << "\n";
}

However noticed something interesting for the second version: if using braced-initialization: there are narrowing conversion warnings here Coliru Viewer to out-right error messages on my gcc 5.9.2
the first version, using std::locale, runs with braced-initialization without errors or warnings but produces a garbage character in front: Coliru Viewer
it seems for both versions calling the std::string ctor with parentheses produces the desired output but not with braced initialization