Thread: Very simple string help needed

I will show you code that extracts values from a comma delimited string. This may help you. I use this in my SpaceX prototype to extract vectors from XML config files.

Code:

template <typename T> bool XMLUtils::ExtractValuesFromString(const std::string & text,const std::string & delim,T *pValues)
{
    bool result = false;
    size_t pos = 0;
    size_t pos2 = text.find(delim,pos);
    int count = 0;
    std::string value;

    while (pos2 != std::string::npos)
    {
        result = true;   //Found at least 1 of the specified delimiters
        if (pos == 0)
        {
            value = text.substr(pos,(pos2 - pos));
        }
        else
        {
            value = text.substr(pos + 1,(pos2 - pos));
        }

        pValues[count] = static_cast<T>(atof(value.c_str()));
        ++count;
        pos = pos2;
        
        pos2 = text.find(delim,pos + 1);
    }

    size_t length = text.length();
    std::string last = text.substr(pos + 1,text.length() - (pos + 1));
    pValues[count] = static_cast<T>(atof(last.c_str()));
   

    return result;
}

Forgive the template code. It is there so that I can use the function for int, float and what have you. Pay attention to how I'm using find to find all the specified delimiters. Forget about the sub string extraction portion as well as the data type stuff.

Here is some code that uses the function:

Code:

const D3DXCOLOR XMLUtils::ExtractColorFromString(const std::string &text)
{
    D3DXCOLOR result = D3DXCOLOR(0.0f,0.0f,0.0f,0.0f);

    float values[4];
    if (ExtractValuesFromString<float>(text,",",values))
    {
       result = D3DXCOLOR(values[0],values[1],values[2],values[3]);
    }
    return result;
}

Originally Posted by Elkvis

if this code is in a production system and is used inside an inner loop of some sort, you could potentially see significant performance gains by eliminating the copy of the object.

I bet you the compiler will optimize it. Plus since the left-hand side and right-hand side are the same, I believe it will become the same thing: initialization.
I don't know if there are special rules for objects, but
int n = 10
and
int n(10)
are the same thing.
Likewise is
std::string str = "Hello World"
and
std::string str("Hello World")

in any case, the way I attack a problem I'm unsure about is to write down in human language what steps *I* would take if I were going to do it by hand. then I translate that into code, and it speeds up the process a lot.

That is an excellent advise, and what every new programmer should do. It teaches how to do proper logic in the code. Which is exactly what you, the OP, right now need.

if this code is in a production system and is used inside an inner loop of some sort, you could potentially see significant performance gains by eliminating the copy of the object.

Doubtful since they are the same thing. The code is from one of my home projects. I never post production code publicly - it is unethical and against my NDA.

Since this is really about find() I fail to see how this adds to the discussion. And if you really must know this is from a section of code that does not need to be super fast. It is not inside of any rendering or update loop and is only performed when each sector is loaded. If I wanted it to be really really fast do you really think I would use XML?

And so to the OP I hope some of what I posted gives you one idea of how to use find(). The documentation for it is a bit confusing so I can certainly understand not getting it the first time. I'm certainly not saying my example is the only way or the best way but it is one way. My goal was to show you one way to use it.

Originally Posted by Elysia

Likewise is
std::string str = "Hello World"
and
std::string str("Hello World")

Strictly speaking, they are not the same thing. The former is copy initialisation, the latter is direct initialisation, and when the constructor in question is declared explicit the former will not compile.

Originally Posted by Bubba

Doubtful since they are the same thing.

Semantically, I think that they are not the same thing, but any reasonable compiler will elide the copying. Still, as a matter of style I do not see a reason to use the more complicated expression here.

The example use could be simplified to:

Code:

const D3DXCOLOR XMLUtils::ExtractColorFromString(const std::string &text)
{
    float values[4] = {0.0f};
    ExtractValuesFromString<float>(text, ",", values);
    return D3DXCOLOR(values[0], values[1], values[2], values[3]);
}

but I do not really see the point other than to simplify your own code.

Originally Posted by Bubba

Since this is really about find() I fail to see how this adds to the discussion.

That is why I usually prefer to write a simplified example instead of taking something from my actual code. It is tough to find something simpler than what nick753 wants, but here's an example that prints the position of a character each time its occurrence is found in a string:

Code:

#include <string>
#include <iostream>

void printEach(const std::string& text, char c)
{
    std::string::size_type i = text.find(c); // Find the first occurrence.
    while (i != std::string::npos)           // Until there are no more occurrences...
    {
        std::cout << i << std::endl;         // Print the position of the occurrence.
        i = text.find(c, i + 1);             // Find the next occurrence.
    }
}

Originally Posted by laserlight

Strictly speaking, they are not the same thing. The former is copy initialisation, the latter is direct initialisation, and when the constructor in question is declared explicit the former will not compile.

Well, I wasn't trying to imply they are the same thing, just they basically translate to the same thing, and therefore, the explicit form suffers no speed penalty.

I fail to see how broken code makes for a good example.

It is not broken. The code functions just fine. As to whether or not it makes un-necessary copies is another matter but does not mean it is broken if my requirements for that section of code do not require the utmost of speed. Besides the arguments presented still are not going to cause me to change the code since it is no big deal in the grand scheme of my program. I think there are bigger fish to fry. Speed has no bearing on this section of code. Parsing the XML via tinyxml is sure to be slower than any copy operation especially if the compiler changes it as has been discussed.

Well, I wasn't trying to imply they are the same thing, just they basically translate to the same thing, and therefore, the explicit form suffers no speed penalty.

I cannot believe we are discussing speed in this thread when the crux of it is to show ways to use the find() function. But I digress. And I'm with just about everyone else here that speed is not going to suffer in any way. True they are not the same thing in the purest sense...but in the end the difference is not enough to cause issues.

Good example code laserlight. The core code I presented that actually used the find function had nothing to do with the section of code that used it...yet that is what was scrutinized. Really amazing.