Is a function argument an implicit cast?

Hi.

I need to store pointers as void* to be able to check that an
(semi-arbitrary) object cannot be used twice.

It looks like this.

template<typename T>
class BaseClass
{
    T t;
};

std::set<const void*> checklist;

template<typename T>
bool testAndSet( const BaseClass<T>& object )
{
    // Insert object into set, if already inserted, return false.
    return checklist.insert( &object ).second;
}

int main()
{
    BaseClass<int> intClass;
    assert( testAndSet( intClass ) && "Should not fail" );
    assert( testAndSet( intClass ) && "Should fail" );
}

Regarding the conversion to const void* when inserting into the set,
this must be safe, right? Since everything that comes into testAndSet()
are implicitly cast to BaseClass<T> the void* must always be the same
for any single object.

In a previous post Alf P. Steinbach showed the following problem.

struct A
{
    int a;
};

struct B : A
{
    virtual ~B() {}
    int b;
};

int main()
{
    B* p1 = new B;
    A* p2 = p1;
    void* pv1 = p1;
    void* pv2 = p2;
    assert( pv1 == pv2 && "Fails!" );
}

But isn't my example safe from that since I do an implicit cast in the
function argument, similar to doing the following.

int main()
{
    B* p1 = new B;
    A* p2 = p1;
    void* pv1 = static_cast<A*>(p1);
    void* pv2 = static_cast<A*>(p2);
    assert( pv1 == pv2 && "Should be ok" );
}

Am I correct about this assumption? Does it say in the standard that two
different pointers to the same object will always be identical after an
implicit cast through a function call like my testAndSet example above?

Thanks,
Daniel