Map insert not working?

map.insert fails every time. If I create a temporary map in the function it works fine.

Code:

---

class OpenGLShaderReference : public ShaderReference
{
        public:
        map<std::string,OpenGLUniform*> uniforms;
}

Uniform* OpenGLShaderReference::GetUniform(std::string name)
{
        OpenGLUniform* uniform = new OpenGLUniform;
        uniform->name=name;
        uniform->index = glGetUniformLocation(program,name.c_str());
               
          this->uniforms.insert(pair<std::string,OpenGLUniform*>(name,uniform));
          if (this->uniforms[name]==NULL) Print("Failed to insert uniform");
          return uniform;
}

---

so it compiles but always prints "Failed to insert uniform"?

if so, maybe set a breakpoint at the this->uniforms.insert(pair...); line and see if the debugger tells you anything useful.

if it doesn't compile, i'd consider std::pair and make sure you have #include <utility>

The debugger lists the pair "materialcolor" (the name string) and 0x00000, even though the local uniform variable is not NULL. It looks as though I did this:

uniforms.insert(std:: pair<std::string, Uniform*>(name,NULL))

But I did not!

It was caused by my misunderstanding of the std::map protocols. I did not realize it was written in the worst most inconvenient way possible.

Others could benefit from the information that solved your case, could you please share it?

Quote:

---

Originally Posted by JMK

It was caused by my misunderstanding of the std::map protocols. I did not realize it was written in the worst most inconvenient way possible.

---

I agree with Xupicor: instead of just criticising the std::map interface, you should share what you did if you think that it was terribly inconvenient. Maybe there is a more convenient method that you simply missed. For example:

Code:

---

Uniform* OpenGLShaderReference::GetUniform(const std::string& name)
{
    // Substitute std::unique_ptr for auto_ptr when it is available.
    std::auto_ptr<OpenGLUniform> uniform(new OpenGLUniform);
    uniform->name = name;
    uniform->index = glGetUniformLocation(program, name.c_str());

    if (!this->uniforms.insert(std::make_pair(name, uniform.get())).second)
    {
        Print("Failed to insert uniform");
    }
    return uniform.release();
}

---

The only way insert will fail is if the key already exists in the map.

Quote:

---

I did not realize it was written in the worst most inconvenient way possible.

---

I find most of the STL interfaces to be quite straightforward and easy to use. After having used .NET containers I can say for sure that the .NET generics were designed to mimic the STL interfaces except for the iterator paradigm...however, that, too shows up in much of the .NET containers and objects.

The STL is fast enough but certainly not fast in every situation and no algorithm or design can make this claim. The STL is fast at doing what it was designed to do and yet also maintain the robustness, abstraction, and extendability that is so crucial to any template library. The STL is extremely stable, well-tested, well thought out, well designed, well maintained, and a huge time and money saver for nearly every single C++ programmer and C++ studio in the world. If you are going to make the claim it has an unwieldy interface then we would like to see some examples. Often this stems from a misunderstanding somewhere. The STL is not perfect but it is a very useful tool. I can't imagine programming today without it - I certainly would not be as productive.

I would also advice you to look up smart pointers since you seem to be using raw pointers.