converting string into char

Question

I know I can do this by str.c_str(), but I do not want a character constant. I want a char so that I can make some modifications.

char* removeDup(char *s)
{


        int len = strlen(s);
        int p,q, idx = -1;
    for(p = 0; p< len; p++)
   {
    char temp = s[p];
    bool flag = true;
    for(q=0;q<p;q++)
    {
        if(s[q] == temp)
        {
            flag = false;
            break;
        }
    }
    if(flag == true)
    {
        s[++idx] = temp;
    }
}
    s[++idx] = '\0';
    return s;
}

if I call this function as below, I get errors;

string s = "abcde";
removeDuplicate(s.c_str());

I need to convert this s into char and not const char.

My suggestion would be to pass in a string instead and skip char* completely — default
– default, Commented Jan 9, 2012 at 13:25

Alok Save · Accepted Answer · 2012-01-09 13:40:55Z

5

To get the underlying data from a std::string You can use:

string::data() or string::c_str(), both return a const char *.

In either case the returned data is const char * because the memory for it is allocated in some read only implementation defined region which an user program is not allowed to modify. Any attempt to modify the returned const char * would result in Undefined Behavior.

So you cannot and should not(through const_cast) modify the returned character string.

The only correct way to achieve this by creating a new char*, allocate it, and copy in the contents from the const char*:

std::string myString = "blabla";
char* myPtr = new char[myString.size() + 1];
myString.copy(myPtr, myString.size());
myPtr[myString.size()] = '\0';

edited Jan 9, 2012 at 13:40

Alok Save

208k56 gold badges449 silver badges540 bronze badges

answered Jan 9, 2012 at 13:22

Luchian Grigore

260k68 gold badges465 silver badges634 bronze badges

Sign up to request clarification or add additional context in comments.

14 Comments

Luchian Grigore Over a year ago

@Roger well, that's impossible. A C-style cast to char* will break the program, as it will result in undefined behavior. Why not use std:string's functions to achieve what you want?

Douglas Leeder Over a year ago

@Roger You need to use an extra buffer - the one returned by c_str is owned by the original string - so you can't modify it.

Alok Save Over a year ago

@Cicada: casting away the constness would be an UB.

Mike Seymour Over a year ago

@WTP: Indeed, but it needs be std::unique_ptr<char[]>, so that the array is correctly deleted.

James Kanze Over a year ago

@Dennis std::vector<char> would be an even better choice, since it takes care of both the allocation and the deallocation. (Really, the only valid choice is to rewrite the function to use iterators---and to hopefully make it readable at the same time.)

|

RC. · Accepted Answer · 2012-01-09 13:32:23Z

2

I would suggest making a copy of the buffer, calling your function, and then setting the original string to the new char buffer. Something like:

std::string str("some string");
char tmp[str.length() + 1];
memset(tmp, 0, sizeof(tmp));
copy(str.begin(), str.end(), tmp);
str = removeDup(tmp);

Using the const buffer returned by c_str() directly and modifying it is asking for trouble. The buffer is owned by the string object and you should think of modifying that as breaking encapsulation and at minimum implementation dependent.

edited Jan 9, 2012 at 13:32

answered Jan 9, 2012 at 13:24

RC.

28.4k10 gold badges80 silver badges94 bronze badges

2 Comments

Alok Save Over a year ago

More than breaking the encapsulation(which probably one could get away with) casting away the const is a guaranteed Undefined Behavior.

Mike Seymour Over a year ago

Note that variable-length arrays are a non-standard extension to C++. If you want portability, use std::vector<char>.

Cpt. Red · Accepted Answer · 2012-01-09 13:27:30Z

1

Just copy it.

string str = "Hello";
char * cStr = new char[str.size()];
memcpy(cStr, str.c_str(), str.size());

answered Jan 9, 2012 at 13:27

Cpt. Red

1023 bronze badges

1 Comment

Mike Seymour Over a year ago

And don't forget to delete the dynamic array when you're finished (or better yet use std::vector<char>). Also, it looks like the evil function in the question requires a zero-terminated string, so use str.size()+1 to include the terminator.

James Kanze · Accepted Answer · 2012-01-09 15:11:11Z

The only way to legally make modifications to a std::string is through it's member functions (including the access paths they indirectly provide). Thus, you should rewrite your removeDup to take std::string::iterator as arguments, something like:

std::string
removeDup( std::string& original )
{
    std::string::iterator current = original.begin();
    std::string::iterator end = original.end();
    while ( current != end ) {
        end = std::remove( current + 1, end, *current );
        ++ current;
    }
    original.erase( end, original.end() );
    return original;
}

(I think this does what your original code does. I can't be sure, because I couldn't really figure out your original code.)

From a design point of view, this is ugly; you should probably pass a std::string const&, and return a new std::string:

std::string
removeDup( std::string const& original )
{
    std::string results;
    std::bitset<UCHAR_MAX + 1> alreadySeen;
    for ( std::string::const_iterator current = original.begin();
            current != original.end();
            ++ current ) {
        if (! alreadySeen.test( static_cast<unsigned char>( *current ) ) ) {
            results += *current;
            alreadySeen.set( static_cast<unsigned char>( *current ));
        }
    }
    return results;
}

The only time you want to get a char* from a std::string is to pass it to legacy code (or C). In such cases, std::string::c_str() is the approved method; if the function you are calling requires a char*, then:

if the function doesn't actually modify the string (it's not const correct, but this is the case for many C functions), then use const_cast on the return value of std::string::c_str(), otherwise
you must allocate a local buffer, and pass it:

std::vector localBuffer( s.begin(), s.end() ); localBuffer.push_back( '\0' ); legacyFunction( &localBuffer[0], localBuffer.size() );

Shawabawa · Accepted Answer · 2012-01-09 13:26:10Z

0

I think you want this method from string:

Copy sequence of characters from string: http://www.cplusplus.com/reference/string/string/copy/

eg. If you had a string 'str', you could do this:

char buf[str.len()+1]
str.copy(buf, str.len())

//terminate with newline
buf[str.len() = '\n']

Hope that helps.

answered Jan 9, 2012 at 13:26

Shawabawa

2,5951 gold badge17 silver badges17 bronze badges

Comments

Pete Cordell · Accepted Answer · 2012-01-09 16:05:53Z

0

In the realm of 'possible' as opposed to 'sensible' you could do:

std::string str("foo");
str = removeDup( std::auto_ptr<char>(strdup(str.c_str()).get() );

But rewriting in terms of std::string would be better.

edited Jan 9, 2012 at 16:05

answered Jan 9, 2012 at 16:00

Pete Cordell

11 bronze badge

1 Comment

Pete Cordell Over a year ago

Although this does assume that malloc and new are synonymous for chars.

Collectives™ on Stack Overflow

converting string into char

6 Answers 6

14 Comments

2 Comments

1 Comment

Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

14 Comments

2 Comments

1 Comment

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related