Russian Qt Forum

C++ (Qt)
typedef struct {
 float r, g, b;
} RGB_Float;
 

C++ (Qt)
c2.r = c0.r + c1.r;
c2.g = c0.g + c1.g;
c2.b = c0.b + c1.b;
 

C++ (Qt)
void DoSomething( some_c_struct * data )
{
 ...
 data->colorOut = (data->color1 + data->color2) / 2;   // операторы для RGB_float
 ...
}
 

C++ (Qt)
#include <TheirAPIHeader.h>
 
inline const RGB_Float operator+(const RGB_Float& a, const RGB_Float& b) {
          RGB_Float result = {a.r+b.r, a.g+b.g, a.b+b.b};
          return result;
}
 

C++ (Qt)
// хотелось бы
struct RGB_Real {
 RGB_Real( void ) { r = g = b = 0.0f; }
 
 float Min( void ) const;
 float Max( void ) const;
 float Gray( void ) const;
// и.т.д
};
 

C++ (Qt)
class RGB_Real : public RGB_Float
{
public:
    RGB_Real( void ) { r = g = b = 0.0f; }
 
    float Min( void ) const;
    float Max( void ) const;
    float Gray( void ) const;
};
 

C++ (Qt)
class RGB_Real
{
public:
 
    operator RGB_Float();
};
 

C++ (Qt)
class MyRGB {
    MyRGB() { _rgb.r = _rgb.g = _rgb.b = 0.0f; }
    MyRGB(const RGB_Float& rgb) : _rgb(rgb) {}
    ~MyRGB() {}
 
     RGB_Float operator RGB_Float() { return reinterpret_cast<RGB_Float&>(*this); }
private:
    RGB_Float _rgb;
}
 

C++ (Qt)
class MyRGB {
public:
    MyRGB() { _rgb.r = _rgb.g = _rgb.b = 0.0f; }
    MyRGB(RGB_Float& rgb) { this = reinterpret_cast<MyRGB*>&rgb; }
    ~MyRGB() {}
 
     RGB_Float& operator RGB_Float&() { return reinterpret_cast<RGB_Float&>(*this); }
     const RGB_Float& operator RGB_Float&() const { return reinterpret_cast<const RGB_Float&>(*this); }
private:
    RGB_Float _rgb;
}
 

C++ (Qt)
extern "C"
{
#include "rgb_float.h"
}
 
class Wrapper: public RGB_Float
{
public:
  Wrapper(const RGB_Float &);
  ...
}
 

C++ (Qt)
class Wrapper:
{
public:
  Wrapper(const RGB_Float &);
  ...
  RGB_Float& data() {}
  const RGB_Float& data() const {}
  ...
private:
  RGB_Float m_val;
}
 

C++ (Qt)
//  void RaiseContract(RGB_Real &);  // здесь плюсовый класс для расчетоы
..
RaiseContract(c_struct->color);   // а данные в структуре С
..
 

C++ (Qt)
RaiseContract((RGB_Real &) c_struct->color);  
 

C++ (Qt)
Wrapper temp(c_struct->color)
RaiseContract(temp);
c_struct->color =  temp.data(); 
 

C++ (Qt)
class RGB_Real
{
public:
    RGB_Real( const RGB_Float & ); 
};
 
//  void RaiseContract(RGB_Real &);  // здесь плюсовый класс для расчетоы
..
RaiseContract(c_struct->color);   // а данные в структуре С
..
 

C++ (Qt)
class Wrapper
{
public:
  Wrapper(RGB_Float &data): m_data(data) {}
 
private:
  RGB_Float &m_data;
}
...
 
RaiseContract(Wrapper(c_struct->color));
 

C++ (Qt)
class Wrapper
{
public:
  Wrapper(RGB_Float &data): m_data(data) {}
 
private:
  RGB_Float &m_data;
}
...
 
RaiseContract(Wrapper(c_struct->color));
 

C++ (Qt)
class Wrapper : public std::reference_wrapper<RGB_Float> {};
 

C++ (Qt)
template <class T>
class wrapper : public std::reference_wrapper<T>
{
public:
    wrapper(T &x) : std::reference_wrapper<T>(x) {}
 
    wrapper& operator=(const T &x) {
        this->get() = x;
        return *this;
    }
 
    wrapper& operator=(const wrapper<T> &x) {
        this->get() = x.get();
        return *this;
    }
 
// + Ещё какой либо функционал, в зависимости от задачи..
};
 
template <class T>
inline const T operator+(const wrapper<T> &x, const wrapper<T> &y) {
    return x.get() + y.get();
}
 
template <class T>
inline const T operator-(const wrapper<T> &x, const wrapper<T> &y) {
    return x.get() - y.get();
}
 
void print(int x) {
    std::cout << "print int: value = " << x << std::endl;
}
 
template <class T>
void print(wrapper<T> &w) {
    std::cout << "print wrapper: value = " << w << std::endl;
}
 
int main()
{
    int a = 10;
    int b = 20;
    int c = 0;
 
    wrapper<int> wa(a);
    wrapper<int> wb(b);
    wrapper<int> wc(c);
 
    wc = wa + wb;
 
    print(wc);
 
    print(c);
 
    return 0;
}
 

C++ (Qt)
typedef wrapper<RGB_Float> RGB_Real;
 

C++ (Qt)
void DrawBuffer( RGB_Float * buf, int width, int height );
 

C++ (Qt)
void DrawBuffer( const std::vector<RGBReal> &buf, int width, int height );
 

C++ (Qt)
class PixBuffer
{
public:
    RGBReal &at( int x, int y );
    const RGBReal &at( int x, int y ) const;
}
 
void DrawBuffer( const PixBuffer &buf, int width, int height );
 

C++ (Qt)
typedef struct {									
	RGB_Float * mBufferBase;	  // данные буфера (3 float на точку)			
 
// здесь десяток членов - простых типов
	SInt32 mFrame;
         ...								
 
	C_Rect mBufferRect;            // SDK структура - самописный rectangle
	C_Matrix mMatrix;		  // SDK структура - самописная матрица 4х4		
 
// здесь опять десяток простых 
	double mTime;
         ...								
 
} DrawBufferRec, * DrawBufferPtr;
 

C++ (Qt)
SInt32 DrawBuffer( DrawBufferPtr theBuffer );   // мой код должен быть в этом вызове API
 

C++ (Qt)
// Рендер - может генерировать DrawBuffer
class Renderer
{
public:
    DrawBuffer run( ... );    // В run используется C-API, возвращает же она уже C++ объект.
};
 
// Рисовальщик - умеет его выводить на всякие разности
class Drawer
{
public:
    void draw( const DrawBuffer &buf );
};
 
// Буфер - сам буфер
class DrawBuffer
{
public:
    DrawBuffer( int w, int h );
 
private:
    DrawBuffer( DrawBufferPtr );    // Прячем конструктор, который умеет создавать объект из C-структуры
    friend class Renderer;                  // Даем возможность методу Renderer::run использовать спрятанный конструктор для создания объектов из C-структуры
}
 

C++ (Qt)
DrawBuffer::DrawBuffer( DrawBufferPtr ptr ) :
    m_drawBuffer( ptr )
{
}
 
DrawBuffer::DrawBuffer( int w, int h ) :
    m_drawBuffer( new DrawBufferRec )
{
    m_drawBuffer->width = w;
    m_drawBuffer->height = h;
}
 

C++ (Qt)
class DrawBuffer
{
    PixArray m_bufferBase;    // Предполагается, что конструктор PixArray умеет конструироваться из указателя на буфер RGB_Float
public:
    DrawBuffer( DrawBufferPtr ptr ) :
        m_bufferBase( ptr->mbufferBase )
    {
    }
}
 

C++ (Qt)
class DrawBuffer_cpp : public DrawBufferRec {	
...								
	RGB_Float_cpp * BufferBase( void )  { return (RGB_Float_cpp *) mBufferBase; }
 	Rect_cpp & BufferRect( void )   { return (Rect_cpp &) mBufferRect; }
	Matrix_cpp & Matrix( void );	     { return (Matrix_cpp &) mMatrix; } 
}

C++ (Qt)
extern "C"
{
typedef struct matrix matrix_type;
void matrix_rotate_x( matrix_type *m, real a );
void matrix_scale( matrix_type *m, real s );
}
 
class Matrix
{
public:
    void rotate_x( real a );
    void scale( real s );
 
private:
    matrix_type m_matrix;
 
// а лучше 
// class priv;
// priv    *d;
};
 
// ---
 
void Matrix::rotate_x( real a )
{
    matrix_rotate_x( &m_matrix, a );
}
 
void Matrix::scale( real s )
{
    matrix_scale( &m_matrix, s );
}