Russian Qt Forum

C++ (Qt)
template <class Ti, class Tp>
class VVectorIndex: public QObject
{  
public:
    VVectorIndex(QObject* parent = 0);
 
    virtual ~VVectorIndex();
    Ti getIndex(Tp*);
    Tp* getPointer(Ti);
    Ti createIndex(Tp* word);
    bool eraseIndex(Ti);
    Ti count(){return Indexes.count();};
    virtual unsigned char getWordVersion(Ti)=0;
    virtual bool incrWordVersion(Ti)=0;
    virtual char getGroupVersion()=0;
    virtual bool incrGroupVersion()=0;
  protected:
    QVector <Tp*> Indexes;
  private:
    virtual bool setWordVersion(Tp*word, unsigned char vers){return false;};
 
    char groupVersion;
    Ti badIndexes;
};
 
class VWord;
 
class VWordIndex: public VVectorIndex<unsigned short, VWord>
{
public:
    VWordIndex(QObject* parent = 0):VVectorIndex<unsigned short, VWord>(parent){};
    ~VWordIndex();
    unsigned char getWordVersion(unsigned short);
    bool incrWordVersion(unsigned short);
    char getGroupVersion();
    bool incrGroupVersion();
 
  private:
    bool setWordVersion(VWord *word, unsigned char vers);
};
 

C++ (Qt)
template <class T>
class base
{
public:
    base() {}
    virtual ~base() {}
 
    virtual void print(const T& x) const = 0;
 
};
 
class derived : public base<double>
{
public:
    virtual void print(const double &x) const {
        std::cout << "derived.print, x = " << x << std::endl;
    }
};
 
 
int main()
{
    base<double> *base = new derived;
 
    base->print(4.5);
 
    return 0;
}
 

C++ (Qt)
 base<double> *base = new derived;
 

C++ (Qt)
 base->print(4.5);
 

C++ (Qt)
 base<double> *base = new derived;
 

C++ (Qt)
 base->print(4.5);
 

C++ (Qt)
base<double> *baseD = new derivedD;
base<float> *baseF = new derivedF;
 

C++ (Qt)
base<double> *baseD = new derivedD;
base<float> *baseF = new derivedF;
 

C++ (Qt)
Расскажите, мне тоже интересно
 

C++ (Qt)
template <class T>
struct my_type_traits
{
typedef T type;
typedef T* pointer_type;
typedef const T& const_reference;
typedef T& reference;
 
// Может содержать свой методы, но обычно это статические функции..
 
static void some_method(const_reference x) { std::cout << "my_type_traits::some_method, x =" << x << std::endl;  }
//...
};
 
// Можно сделать специализациию на my_type_traits или написать свой
template<>
struct my_type_traits<double>
{
//...
static void some_method(const_reference x) { std::cout << " my_type_traits<double>, x = " << x << std::endl; }
};
 
template <class T, class Traits = my_traits<T> >
class my_class 
{
public:
typedef typename Traits::type type;
typedef typename Traits::pointer_type pointer_type;
typedef typename Traits::const_reference const_reference;
typedef typename Traits::reference reference;
//...
type my_method(const_reference x) { 
    Traits::some_method(x);
   //...   
    return x;
} 
// Ну и т.д.
};
 
//Используется это так
 
my_class<int> mi; 
mi.some_method(2); 
 
my_class<double> md;
md.some_method(3.14); 
 
 

C++ (Qt)
struct Point3D  { double x, y, z; };
struct Point3F  { float x, y, z; };
struct Point3W { float x, y, z, w; };
 

C++ (Qt)
std::vector <Point3D> vec1;
std::vector <Point3F> vec2;
и.т.д.
 

C++ (Qt)
struct Point3D  { double x, y, z; };
struct Point3F  { float x, y, z; };
struct Point3W { float x, y, z, w; };
 

C++ (Qt)
std::vector <Point3D> vec1;
std::vector <Point3F> vec2;
и.т.д.
 

C++ (Qt)
struct base_point {
virtual ~base_point() {}
};
 
template <class T>
struct point : public base_point
{
    T x, y, z;
};
 
list<base_point*> list_of_points;
 

C++ (Qt)
typedef vector<PointF> vector_of_pointsf;
typedef vector<PointD> vector_of_pointsd;
...
 

C++ (Qt)
class CModel {
 ...
 CoordVec * mCoord; // или CoordVec & mCoord; 
};
 

C++ (Qt)
enum typeOfCoordVector { VectorPointF, VectorPointD};
 
struct base_coord_vec
{
    virtual ~base_coord_vec() {}
    virtual type_coord_vec() const = 0;
};
 
struct coord_vec_d : public base_coord_vec
{
    typedef std::vector<PointD> vector_type;
    vector_type vector;
    virtual type_coord_vec() const { return VectorPointD; }
}; 
 
struct coord_vec_f : public base_coord_vec
{
    typedef std::vector<PointF> vector_type;
    vector_type vector;
    virtual type_coord_vec() const { return VectorPointF; }
}; 
 
class CModel {
    base_coord_vec *mCoord;
};
 

C++ (Qt)
vector<variant>
 

C++ (Qt)
template <class T>
class CModel {
 ...
 vector <T> mCoord;
};
 

C++ (Qt)
typedef std::vector<variant> super_vector; 
 

C++ (Qt)
struct CoordVec {
 virtual size_t size( void ) const = 0;
 virtual Point3D & Get3D( size_t index ) = 0;
 virtual Point3F & Get3F( size_t index ) = 0;
 virtual Point3W & Get3W( size_t index ) = 0;
  // то же для Set и.т.д
};
 
template <class T>
struct CoordVecT : public CoordVec {
 virtual size_t size( void ) const { return mData.size(); }
..
 vector <T> mData;
};
 

C++ (Qt)
virtual typeOfVector type() const = 0;
 

C++ (Qt)
void Append( CoordVec & dst, const CoordVec & src );
 

C++ (Qt)
template <class T>
class CModel {
    typedef T pointType;
    typedef std::vector<T> vectorType;
 
    vectorType *mCoord;
};
 

C++ (Qt)
template<class T>
struct tester
{
    static bool is_same(const T&) { return true; }
    template <class U>
    static bool is_same(const U&) { return false; }
};
 

C++ (Qt)
int i;
std::cout << tester<int>::is_same(i) << std::endl;
std::cout << tester<long>::is_same(i) << std::endl;
 
A *a = new A;
std::cout << tester<A>::is_same(*a) << std::endl;
std::cout << tester<B>::is_same(*a) << std::endl;
 
 

Bash
true
false
 
true
false
 

C++ (Qt)
template <class T1, class T2>
void Append( T1 & dst. const T2 & src );
 

C++ (Qt)
template <class T1, class T2>
void Append( T1 & dst. const T2 & src );
 

C++ (Qt)
template<>
void Append<vestor<PointD>, PointD>(vestor<PointD>& dst, const PointD &src);
 

C++ (Qt)
template<>
void Append<vestor<PointD>, PointD>(vestor<PointD>& dst, const PointD &src);
 

C++ (Qt)
class CModel {
 ...
 CoordVec * mCoord;
};
 

C++ (Qt)
template <class Point>
void Append( vector<Point> & dst, const vector<Point> & src ) {...}
 

C++ (Qt)
template <>
void Append<PointF>( vector<PointF> & dst, const vector<PointF> & src ) {...}
 

C++ (Qt)
void Append( CoordVec & dst, const CoordVec & src )
{
 switch (dst.Format()) {
  case format_3doub:
    switch (src.Format()) {
     case format_3doub:
     {
       CoordVecT <Point3D> & srcT = (CoordVecT <Point3D> &) src;
       CoordVecT <Point3D> & dstT = (CoordVecT <Point3D> &) dst;
       dst.mData.insert(...);
       break;
     }
     ...
  .... // и.т.д
    }
  .... // и.т.д
 }
 
}
 

C++ (Qt)
enum PointType {TypePointD, TypePointF, TypePointX, TypeUnknown};
 
template <class T>
struct traits {
static PointType type() { return TypeUnknown; }
};
 
template<>
struct traits<PointF>
{
static PointType type() { return TypePointF; }
};
 
template<>
struct traits<PointD>
{
static PointType type() { return TypePointD; }
};
 
template<>
struct traits<PointX>
{
static PointType type() { return TypePointX; }
};
 

C++ (Qt)
template <class Point>
void Append(vector<Point>& dst, const vector<Point> & src)
{
    PointType pt = traits<Point>::type();
    switch (pt) {
    case TypePointF:  {...} break;
    case TypePointD:  {...} break;
    case TypePointX:  {...} break;
    default: {...}   
    }
}
 

C++ (Qt)
template <class T>
class CModel {
..
 vector <T> mCoord;
};
 

C++ (Qt)
template <class T>
void someMethod(CModel<T> &x) {
   x.someNonTemplateParametr = value; // ну и т.д.
}
 

C++ (Qt)
enum PointType {TPointF, TPointX, TUnknown};
 
// Предварительное объявление
template <class T>
struct derived;
 
// класс base
struct base
{
    virtual ~base() {}
    virtual PointType type() const = 0;
 
    template <class T>
    T get(std::size_t index) const {
           switch(type()) {
           case TPointF: {
                 derived<PointF> *d = static_cast<derived<PointF>*>(this);
                 return d->vector[index];
           } break;
           case TPointX: {
                 derived<PointX> *d = static_cast<derived<PointX>*>(this);
                 return d->vector[index];
           } break;
        }
        return T();
    }
 
    template <class T>
    void set(std::size_t index, const T& val) {
        switch(type()) {
           case TPointF: {
                 derived<PointF> *d = static_cast<derived<PointF>*>(this);
                 d->vector[index] = val;
           } break;
           case TPointX: {
                 derived<PointX> *d = static_cast<derived<PointX>*>(this);
                 d->vector[index] = val;
           } break;
        }
    }
}; 
 
// Реализация derived
template <class T>
struct derived : public base
{
    virtual PointType type() const { return traits<T>::type(); }
    std::vector<T> vector;
};
 
// объявляем некую функцию, которая принимает базовый класс base
void func(base *x) {
   x->set(0, PointF(1,2,3))
   std::cout << x->get(0) << std::endl;
}
 

C++ (Qt)
class CModel {
  ...
  CoordVec * mPosition;   // собственно координаты точек
  CoordVec * mNormal;    // нормали (перпендикуляры) к точкам
  CoordVec * mSрaceUV;  // позиции точек в UV(W) пространстве 
  CoordVec * mBlur;        //  позиции motion blur
  CoordVec * mNURBS; 
 
  // и.т.д  
};
 

C++ (Qt)
template <class T1. class T2. class T3... >
class CModel {
// вставить эту лабуду в проекте везде-везде
// и если у CModel появился новый член..
 

C++ (Qt)
// CModelUser
Point3F pt = model.mCoordinate->GetPoin3F(index);
if (model.mSpaceUV) {   // UV имеются?
 // крутим UV
}
 

C++ (Qt)
struct super_vector
{
    TypeOfPoint type;
    std::vector<variant> vector;
};
 

C++ (Qt)
void Append(super_vector& dst, const super_vector &src)
{
    if (dst.type == TPointF) {
        PointF p1 = dst.vector[index].get<PointF>();
        ...
        dst.vector[index] = PointF(1,2,3);
    } 
 
}
 

C++ (Qt)
struct base_data
{
    virtual ~base_data() {}
};
 
template <class T>
struct data : public base_data
{
    data() {}
    data(const T& val) : value(val) {}
    T value;
};
 
class variant
{
public:
    variant() {}
 
    template <class T>
    variant(const T& val) {
        _data = ssc::counted_ptr<base_data>(new data<T>(val));
    }
 
    template <class T>
    void set(const T& val) {
        _data = ssc::counted_ptr<base_data>(new data<T>(val));
    }
    template <class T>
    T get(bool *is_valid = 0) const {
        data<T> *d = dynamic_cast<data<T>*>(_data.get());
        if (d) {
            if (is_valid)
                *is_valid = true;
            return d->value;
        }
        if (is_valid)
            *is_valid = false;
        return T();
    }
 
    bool is_empty() const { return _data.is_null(); }
 
private:
    ssc::counted_ptr<base_data> _data;
};
 
 
std::vector<variant> v;
    v.push_back(2.3);
    v.push_back(std::string("hello!"));
    v.push_back(1);
 
 
    std::cout << v[0].get<double>() << std::endl;
    std::cout << v[1].get<std::string>() << std::endl;
    std::cout << v[2].get<int>() << std::endl;
 

C++ (Qt)
if (model.mSpaceUV) {
 mSpaceUV->SetPoinr3F(0, (mSpaceUV->GetPoint3F(0) + mSpaceUV->GetPoint3F(1)) * 0.5); 
}
 

C++ (Qt)
struct base
{
    viryual ~base() {}
    template <class Derived, class Point>
    void set(size_t index, const Point &p) {
        Derived *d = dynamic_cast<Derived*>(this);
        if (d)
            d->vector[index] = p;
    } 
    template <class Derived, class Point>
    Point get(size_t index) const {
        Derived *d = dynamic_cast<Derived*>(this);
        if (d)
           return d->vector[index];
        return Point();
    }
};
 

C++ (Qt)
void set(const super_point &sp);
 

C++ (Qt)
set(PointF(1,2,3));
set(PointD(3,2,1));
...
 

C++ (Qt)
void DrawOpenGL( CoordVec * coord )
{
 CoordVecT <Point3D> * coordD = dynamic_cast <CoordVecT <Point3D> *> (coord);
 if (coord) 
  glDrawFunction_d(&coordT[0].x, coordT->size());
 else
  CoordVecF <Point3F> * coordF = dynamic_cast <CoordVecT <Point3F> *> (coord);
  ...
}
 

C++ (Qt)
void Append( CoordVec & dst, const CoordVec & src );
CoordVec & operator = ( const CoordVec & src );
 

C++ (Qt)
class SuperPoint
{
public:
    SuperPoint(const double &x1, const double &x2, const double &x3, const double &x4)
        : _x1(x1), _x2(x2), _x3(x3), _x4(x4) {}
     SuperPoint(const PointF &p) : _x1(p.x), _x2(p.y), _x3(p.z), _x4(0) {}
     SuperPoint(const PointD &p) : _x1(p.x), _x2(p.y), _x3(p.z), _x4(0) {}
     //...
     PointF toPointF() const { return PointF(x1, x2, x3); }
     PointD toPointD() const { return PointD(x1, x2, x3); }
     //....
private:
    double x1, x2, x3, x4;     
};
 

C++ (Qt)
struct base
{
    virtual ~base() {}
    virtual Format format() const = 0;
    virtual SuperPoint get(size_t index) const  = 0;
    virtual void set(size_t index, const SuperPoint &sp) = 0;
};
 
struct derivedF : public base
{
    virtual Format format() const { return TPointF; }
    virtual SuperPoint get(size_t index) const {
        return SuperPoint(vector[index]);
    }
    virtual void set(size_t index, const SuperPoint &sp) {
        vector[index] = sp.toPointF();
    }
    std::vector<PointF> vector;
};
 
// ...
 

C++ (Qt)
template <class T> 
class CoordVecT : public CoordVec {
 virtual TBigPoint Get( size_t index ) const { return mData[index]; }
 virtual void Set( size_t index, const TBigPoint & pt ) { mData[index] = pt; }
..
 vector <T> mData;
};