Russian Qt Forum

C++ (Qt)
class A {
...
};
 
class B {
...
};
 
A *a = new A;
B *b = new B;
 
size_t address_a = reinterpret_cast<size_t>(a); 
size_t address_b = reinterpret_cast<size_t>(b);
 
if (address_a != address_b) 
    ....
else
    ....
 

C++ (Qt)
inline bool equal (void *a, void *b) { return a == b; }
 
A *a; B *b;
if (equal (a, b))
 

C++ (Qt)
A *a; B *b;
if (std::equal <void *> (a, b))
 

C++ (Qt)
if ((char *) A == (char *) B))
 

C++ (Qt)
typedef size_t address_type // или typedef void* address_type или typedef char* address_type
...
virtual address_type address() const = 0;
 

C++ (Qt)
address_type address() const { return reinterpret_cast<address_type>(m_receiver); }
 

C++ (Qt)
bool compare(base_connection2<S_arg1, S_arg2> *bc) const {
	if ((bc->type() == MEM_FUN_CONNECTION) && (bc->address() == address())) {
	    mem_fun_connection2<S_arg1, S_arg2, R_receiver, R_return, R_arg1, R_arg2> *mfc = dynamic_cast<mem_fun_connection2<S_arg1, S_arg2, R_receiver, R_return, R_arg1, R_arg2> *>(bc);
		if (m_slot_is_const)
		    return (mfc) ? (mfc->m_slot_pack.m_const_slot == m_slot_pack.m_const_slot) : false;
		return (mfc) ? (mfc->m_slot_pack.m_slot == m_slot_pack.m_slot) : false;
	}
	return false;
    }
 

C++ (Qt)
typedef size_t address_type // или typedef void* address_type или typedef char* address_type
...
virtual address_type address() const = 0;
 

C++ (Qt)
if (static_cast <void*> (&a) == &b)
 

C++ (Qt)
void * theNode; 
..
if ((size_t) theNode & 1 != 0)  {     // взведен младший бит - это parent нод 
 Parent * theParent = (Parent *)((size_t) theNode & NODE_MASK);
 ...
}  
else {
 Leaf * theLeaf = (Leaf *) theNode;  // это leaf нод
 ..
}
 

C++ (Qt)
class A
{
public:
    void func1() {}
    void func2() {}
};
 
void *addr1 = (void*)&A::func1;
void *addr2 = (void*)&A::func2;
 
if (addr1 != addr2)
...
elae
...
 

C++ (Qt)
#include <iostream>
#include <list>
#include <ctime>
#include <cstdlib>
#include <cstdio>
 
using namespace std;
 
enum type_derived { TYPE_INT, TYPE_F };
 
class Base
{
public:
    Base() {}
    virtual ~Base() {}
    virtual void print() = 0;
    virtual type_derived type() const = 0;
};
 
class DerivedInt : public Base
{
public:
    DerivedInt(int id = 0) : m_id(id) {}
    void print() { /*cout << "DerivedInt, id = " << m_id << endl;*/ }
    type_derived type() const { return TYPE_INT; }
    void myFunc() { /*cout << "DerivedInt, id = " << m_id << endl;*/ } // not virtual
private:
    int m_id;
};
 
class DerivedF : public Base
{
public:
    DerivedF(float id = 0.0f) : m_id(id) {}
    void print() { /*cout << "DerivedF, id = " << m_id << endl;*/ }
    type_derived type() const { return TYPE_F; }
    void myFunc() { /*cout << "DerivedF, id = " << m_id << endl;*/ } // not virtual
private:
    float m_id;
};
 
typedef list<Base*> ListBase;
typedef list<Base*>::iterator Iter;
 
void generate(ListBase &l, size_t N) {
    for (size_t i = 0; i < N; ++i) {
        if (rand() % 2)
            l.push_back(new DerivedInt(i));
        else
            l.push_back(new DerivedF(float(i)));
    }
}
 
void clearList(ListBase &l) {
    for (Iter it = l.begin(); it != l.end(); ++it) {
        delete *it;
    }
    l.clear();
}
 
void test_dynamic_cast(ListBase &l) {
    Iter it = l.begin();
    for(; it != l.end(); ++it) {
        DerivedF *obj = dynamic_cast<DerivedF*>(*it);
        if (obj)
            obj->myFunc();
    }
}
 
void test_virtual_fun(ListBase &l) {
    Iter it = l.begin();
    for(; it != l.end(); ++it) {
        if ((*it)->type() == TYPE_F) {
            DerivedF *obj = static_cast<DerivedF*>(*it);
            obj->myFunc();
        }
    }
}
 
int main()
{
    ListBase lb;
    size_t Num = 20000000;
    srand(time(0));
    generate(lb, Num);
 
    clock_t tStart = clock();
    test_dynamic_cast(lb);
    //test_virtual_fun(lb);
    cout << (float)(clock() - tStart) / CLOCKS_PER_SEC << endl;
 
    clearList(lb);
    return 0;
}
 

C++ (Qt)
typedef list<Base*> ListBase;
typedef list<Base*>::iterator Iter;
 

C++ (Qt)
void generate(ListBase &l, size_t N) {
    for (size_t i = 0; i < N; ++i) {
        if (rand() % 2)
            l.push_back(new DerivedInt(i));
        else
            l.push_back(new DerivedF(float(i)));
    }
}
 

C++ (Qt)
void test_dynamic_cast(ListBase &l) {
    Iter it = l.begin();
    for(; it != l.end(); ++it) {
        DerivedF *obj = dynamic_cast<DerivedF*>(*it); // Один вызов dynamic_cast
        if (obj)
            obj->myFunc(); // один вызов не виртуального метода!
    }
}
 
void test_virtual_fun(ListBase &l) {
    Iter it = l.begin();
    for(; it != l.end(); ++it) {
        if ((*it)->type() == TYPE_F) { // Один вызов виртуального метода
            DerivedF *obj = static_cast<DerivedF*>(*it); // Пренебрегаем издержками на вызов static_cast 
            obj->myFunc(); // один вызов не виртуального метода!
        }
    }
}
 

C++ (Qt)
void test_virtual_fun(ListBase &l) {
    Iter it = l.begin();
    for(; it != l.end(); ++it) {
        if ((*it)->type() == TYPE_F) { // Один вызов виртуального метода
            DerivedF *obj = static_cast<DerivedF*>(*it); // Пренебрегаем издержками на вызов static_cast 
            obj->myFunc(); // один вызов не виртуального метода!
        }
    }
}
 

C++ (Qt)
Base * base = *it;
int sum = 0;
for (size_t i = 0; i < NUM_CALL; ++i)
 sum += base->typeVirtual();
 

C++ (Qt)
Base * base = *it;
int sum = 0;
for (size_t i = 0; i < NUM_CALL; ++i) {
 DerivedF * derF = dynamic_cast <DerivedF *> (base);
 if (derF) 
  sum += derF->typeNonVirtial();
 else {
  DerivedInt * derInt = dynamic_cast <DerivedInt *> (base);
  if (derInt) 
   sum += derInt->typeNonVirtial();
 }
}
 

C++ (Qt)
void TestVirtual( const QVector <CBase *> & vec )
{
    QTime begT = QTime::currentTime();
 
        int sum = 0;
        for (int i = 0; i < vec.size(); ++i) {
                CBase * base = vec[i];
                for (size_t j = 0; j < NUM_CALL; ++j)
                        sum += base->typeVirtual(); // Один вызов виртуальной функции
        }
 
        int msecs = begT.msecsTo(QTime::currentTime());
    qDebug() << "TestVirtual time(sec): " << (msecs / 1000.0f) << "sum =" << sum;
}
 
void TestNonVirtual( const QVector <CBase *> & vec )
{
    QTime begT = QTime::currentTime();
 
        int sum = 0;
        for (int i = 0; i < vec.size(); ++i) {
                CBase * base = vec[i];
                for (size_t j = 0; j < NUM_CALL; ++j) {
                        CBaseA * a = dynamic_cast<CBaseA *> (base); // Раз: вызов dynamic_cast
                        if (a)
                                sum += a->typeNonVirtual(); // + Нужно учитывать дополнительное время от вызова обычной функции
                        else {
                                CBaseB * b = dynamic_cast<CBaseB *> (base); // Два: Вызов dynamic_cast 
                                if (b)
                                        sum += b->typeNonVirtual(); // Не учитываем добавочное время от этой операции?
                        }
 
                }
        }
 
        int msecs = begT.msecsTo(QTime::currentTime());
    qDebug() << "TestNonVirtual time(sec): " << (msecs / 1000.0f) << "sum =" << sum;
}
 

C++ (Qt)
dynamic_cast:    (1.56, 1.54, 1.54) sec;  <t> = 1.547 sec
virtual_fun:          (1.49, 1.49, 1.48) sec;  <t> = 1.487 sec 
 

C++ (Qt)
void TestVirtual( const QVector <CBase *> & vec )
{
    QTime begT = QTime::currentTime();
 
        int sum = 0;
        for (int i = 0; i < vec.size(); ++i) {
                CBase * base = vec[i];
                for (size_t j = 0; j < NUM_CALL; ++j)
                        sum += base->typeVirtual(); // Без изменений
        }
 
        int msecs = begT.msecsTo(QTime::currentTime());
    qDebug() << "TestVirtual time(sec): " << (msecs / 1000.0f) << "sum =" << sum;
}
 
void TestNonVirtual( const QVector <CBase *> & vec )
{
    QTime begT = QTime::currentTime();
 
        int sum = 0;
        for (int i = 0; i < vec.size(); ++i) {
                CBase * base = vec[i];
                for (size_t j = 0; j < NUM_CALL; ++j) {
                         sum += base->typeNonVirtual(); // Для сравнения: оставим только вызов не виртуальной функции 
                }
        }
 
        int msecs = begT.msecsTo(QTime::currentTime());
    qDebug() << "TestNonVirtual time(sec): " << (msecs / 1000.0f) << "sum =" << sum;
}
 

C++ (Qt)
TestVirtual time(sec):  0.673 sum = 157286400 
TestNonVirtual time(sec):  0 sum = 157286400 
 

C++ (Qt)
TestVirtual time(sec):  1.529 sum = 157286400 
TestNonVirtual time(sec):  0.995 sum = 157286400 
 

C++ (Qt)
TestVirtual time(sec):  1.696 sum = 157286400 
TestNonVirtual time(sec):  5.348 sum = 157286400 
 

C++ (Qt)
TestVirtual time(sec):  1.696
TestNonVirtual time(sec):  1.736