C / C++ / MFC

11-Jul-06 19:28

I'm trying a double indirect look-up table for some function pointer in my app (yep, I have good reason).
I'm trying to use std::map for the table but (because of the double indirection) I need to use a "std::map*"
Which I don't know how to map[index] (with a pointer)

Now perhaps I'm misusing it, I'm not sure (I know nothing of STL and I have some problem understanding its header)

Anyway here is my code (problem explained in red), if you could give me some tips.....

static std::map<const char*, SEL> map_sels;
static std::map<OClass, std::map<SEL, IMP>*> map_imps;

void id::GetImpAlways(const char* name, SEL& sel, IMP& imp)
{
    if( !_handle )
        throw gcnew ObjectDisposedException(Class()->Name);

    if(map_sels.find(name) == map_sels.end())
    {
        sel = sel_register_name(name);
        map_sels[name] = sel;
    }
    else
    {
        sel = map_sels[name];
    }

    std::map<SEL, IMP> * class_imps; <font color="red">// here I get the problematic "map *"</font>
    if(map_imps.find(_handle->class_pointer) == map_imps.end())
    {
        class_imps = new std::map<SEL, IMP>();
        map_imps[_handle->class_pointer] = class_imps;
    }
    else
    {
        class_imps = map_imps[_handle->class_pointer];
    }

    if(class_imps->find(sel) == class_imps->end())
    {
        imp = get_imp(_handle->class_pointer, sel);
        if( !imp )
            throw gcnew ObjectiveCException("No such method");
        class_imps[sel] = imp;  <font color="red">// can't do that with 'map*', what should I so?</font>
    }
    else
    {
        imp = class_imps[sel]; <font color="red">// can't do that with 'map*', what should I so?</font>
    }
}
<pre>

Re: Problem with STL [modified]

Steve Echols11-Jul-06 19:40

Steve Echols

11-Jul-06 19:40

Have you tried dereferencing the pointer like:

*class_imps[sel] = imp;<br />
<br />
and <br />
<br />
imp = *class_imps[sel];

- S
50 cups of coffee and you know it's on!

Super Lloyd11-Jul-06 19:50

11-Jul-06 19:50

I am afraid it will create a copy or affect a copy.
I need to alter the static global variable!!

I hate this stupid C++ copy policy, I need to affect the real shared object!!

Steve Echols11-Jul-06 20:48

Steve Echols

11-Jul-06 20:48

Yeah, I agree. I use pointers for storing my objects in containers (right or wrong), just because I know (or think I know) there's only one instance of my object lying around.

I think these classes are good for simple intrinsic types, like ints, etc., but get kind of irritating when you have to define copy, less than and assignment operators for your classes. Just my opinion, of course.....

- S
50 cups of coffee and you know it's on!

Super Lloyd11-Jul-06 19:50

Re: Problem with STL [modified]

11-Jul-06 19:50

BTW, never mind my problem.
The program crash at the first line:
if(map_sels.find(name) == map_sels.end())

How do I do?
I have a home made C hashtable possibly I should use it instead :-/

Super Lloyd11-Jul-06 20:14

Re: Problem with STL [modified]

11-Jul-06 20:14

Never mind STL...
I can't even add an element, it throws exception like:

at std._Tree<std::_Tmap_traits<void *,void *,std::less<void *>,std::allocator<std::pair<void * const,void *> >,0> >._Lbound(_Tree<std::_Tmap_traits<void \*\,void \*\,std::less<void \*>\,std::allocator<std::pair<void \* const\,void \*> <\,0> >* , Void** _Keyval)

at std.map<void *,void *,std::less<void *>,std::allocator<std::pair<void * const,void *> > >.[](map<void \*\,void \*\,std::less<void \*>\,std::allocator<std::pair<void \* const\,void \*> > >* , Void** _Keyval)

And what is it supposed to mean?
I just try to run this simple code:

static std::map<void*, void*> map_sels;
map_sels[(void*)name] = (void*)sel;

I dropped it, I will use my C Hashtable.
At least it is simple to use, make no copy and no fuss!... Mad | :mad:

-- modified at 2:17 Wednesday 12th July, 2006

Stephen Hewitt11-Jul-06 20:55

11-Jul-06 20:55

Your problem has nothing to do with maps: it's a simple pointer error. Here's the relevant bits of your code:

std::map<SEL, IMP> * class_imps; // here I get the problematic "map *"
// ...
class_imps[sel] = imp;  // can't do that with 'map*', what should I so?
// ...

class_imps is a pointer but you're using it as if it was a map. This should look like this:

(*class_imps)[sel] = imp;

Here's an example to make this clearer:

class Foo
{
    void Bar();
};
 
void SomeFunction()
{
    Foo *pFoo = new Foo();
    pFoo.Bar(); // Error. Should be pFoo->Bar() or (*pFoo).Bar().
    delete pFoo;
}

Steve

-- modified at 3:01 Wednesday 12th July, 2006

PS: Use typedefs instead or repeating the long map types all over the place.

Super Lloyd11-Jul-06 21:02

11-Jul-06 21:02

I knew I was calling the operator on an invalid object.

But I don't want to use "plain object" (as opposed to pointer).
if I do that, as far as I know, I will work with copy of the object, not the real object.

And I don't care about the life of the copies!

Anyway I dropped STL and used my own C implementation of hashtable.
No copy, no fuss... Poke tongue | ;-P

Stephen Hewitt11-Jul-06 21:15

11-Jul-06 21:15

I didn't suggest you not use a pointer. I suggested you don't confuse the pointer with what it points to. You done this:

class_imps[sel] = imp;

I suggested you do this:

(*class_imps)[sel] = imp;

In the first you're not even using the map, you're using a pointer to a map. In the second you're using the map and the only thing copied is imp when the map makes a copy to store. Given that the map's mapped type is IMP this is exactly right.

Steve

Super Lloyd11-Jul-06 21:39

11-Jul-06 21:39

You misunderstood what I said. I said the same thing as you!

That's understandable, as I probably confused you is when I implyed that (*class_imps) was making a copy.
Of course it doesn't, silly me!
Poke tongue | ;-P

Too late I am using my C Hashtable now.
It works well and there is absolutely no copy whatsover (whereas std::map use some sort of default allocator as far as I know).

beside I was not able to use it at all!

example:
std::map<void*, void*> map;
map[(void*)1] = (void*) 2;

is throwing some mysterious (and C++) looking exception.

Stephen Hewitt11-Jul-06 21:50

11-Jul-06 21:50

Super Lloyd wrote:
It works well and there is absolutely no copy whatsover

You're wrong there. If it stores pointers then the pointers are copied; same as with a map of pointers. If it stores IMPs then the IMP must be copied; again the same as a map of IMPs.

I tried your code and it works fine. Here's what I tested:

#include <map>
#include <iostream>
 
int main(int argc, char *argv[])
{
    using namespace std;
 
    typedef map<void*, void*> VoidStar2VoidStarMap;
 
    VoidStar2VoidStarMap MyMap;
    MyMap[reinterpret_cast<void*>(0)] = reinterpret_cast<void*>(1);
 
    cout << MyMap[reinterpret_cast<void*>(0)] << endl;
 
    return 0;
}

The reinterpret_cast<void*> is the same as the (void*) cast in your code. I make it a rule never to use C-style casts.

You're using managed C++ aren't you? I use unmanaged C++ - I don't approve of managed C++.

Steve

Super Lloyd11-Jul-06 22:11

11-Jul-06 22:11

Stephen Hewitt wrote:
You're wrong there. If it stores pointers then the pointers are copied; same as with a map of pointers. If it stores IMPs then the IMP must be copied; again the same as a map of IMPs.

Hum.. you're right....

Stephen Hewitt wrote:
I tried your code and it works fine.

does it?

Stephen Hewitt wrote:
You're using managed C++ aren't you? I use unmanaged C++ - I don't approve of managed C++.

I confess that I'm not that at ease with native C++.
I jumped from C to C#/Managed C++ (well I did some ObjectiveC & Java too)

But everytime I should do pure C++ brrr....
Not too mention that code that did compile in 1995 no longer compiled in 1998! (yes this way! not the opposite!)
And that GCC and CL don't support the same set of C++ D'Oh! | :doh:

Beside many tests failed to prove to me that C++ perform that much faster, so why bother Poke tongue | ;-P

Stephen Hewitt11-Jul-06 22:26