Question

I can see that almost all modern APIs are developed in the C language. There are reasons for that: processing speed, low level language, cross platform and so on.

Nowadays, I program in C++ because of its Object Orientation, the use of string, the STL but, mainly because it is a better C.

However when my C++ programs need to interact with C APIs I really get upset when I need to convert char[] types to C++ strings, then operate on these strings using its powerful methods, and finally convert from theses strings to char[] again (because the API needs to receive char[]).

If I repeat these operations for millions of records the processing times are higher because of the conversion task.
For that simple reason, I feel that char[] is an obstacle in the moment to assume the C++ as a better c.

I would like to know if you feel the same, if not (I hope so!) I really would like to know which is the best way for C++ to coexist with char[] types without doing those awful conversions.
Thanks for your attention.

Answer 1

The C++ string class has a lot of problems, and yes, what you’re describing is one of them.

More specifically, there is no way to do string processing without creating a copy of the string, which may be expensive.

And because virtually all string processing algorithms are implemented as class members, they can only be used on the string class.

A solution you might want to experiment with is the combination of Boost.Range and Boost.StringAlgo.

Range allows you to create sequences out of a pair of iterators. They don’t take ownership of the data, so they don’t copy the string. they just point to the beginning and end of your char* string.

And Boost.StringAlgo implements all the common string operations as non-member functions, that can be applied to any sequence of characters. Such as, for example, a Boost range.

The combination of these two libraries pretty much solve the problem. They let you avoid having to copy your strings to process them.

Another solution might be to store your string data as std::string‘s all the time. When you need to pass a char* to some API functoin, simply pass it the address of the first character. (&str[0]).

The problem with this second approach is that std::string doesn’t guarantee that its string buffer is null-terminated, so you either have to rely on implementation details, or manually add a null byte as part of the string.