Russian Qt Forum

C++ (Qt)
struct CData {
 int mValue;
 ....
 std::vector <float> mTail;
};

C++ (Qt)
struct CData {
 int mValue;
 ....
 int tailCount; 
 float mTail[1];
};

C++ (Qt)
union  {
 float raz[1];
 float dva[2];
 float tri[3];
};

C++ (Qt)
float mData[3];
 

C++ (Qt)
struct CData {
 int mValue;
 ....
 int tailCount;  // если у каждого свой счетчик
 int tailIndex;
};

Bash
elapsed time: 400 msec
elapsed time: 1405 msec
elapsed time: 5797 msec
 

C++ (Qt)
template <class R>
struct getter : public boost::static_visitor<R>
{
    getter(size_t i) : index(i) {}
 
    template <class V>
    R operator()(V & v) const
    {
        return v[index];
    }
 
    R operator()(R v) const
    {
        if (index) throw std::out_of_range("out of range");
        return v;
    }
 
private:
    size_t index;
};
 
template <class R, class V>
R& get(size_t i, V & v)
{
    return boost::apply_visitor(getter<R&>(i), v);
}
 
 
 
const int TEST_COUNT = 50 * 1024 * 1024;
 
struct CData {
    float val;
};
 
struct CData2 {
    boost::variant<std::vector<float>, float> vec; 
// или boost::variant<std::vector<float>, std::array<float, MAGIC_BUF>> vec; 
// Или написать свою обёртку над таким вариантом, которая внешне была аналогична обычному вектору, например.
};
 
struct CData3 {
    QList<float> vec;
};
 
 
template <class F>
void run(F f)
{
    auto start = std::chrono::high_resolution_clock::now();
    f();
    auto stop = std::chrono::high_resolution_clock::now();
 
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
 
    std::cout << "elapsed time: " << elapsed << " msec" << std::endl;
}
 
int main()
{
    std::mt19937 gen;
    std::uniform_real_distribution<float> dist(0.0f, 1.0f);
 
    run([&]()
    {
 
        CData * data = new CData[TEST_COUNT];
            for (int i = 0; i < TEST_COUNT; ++i)
                data[i].val = dist(gen);
            delete [] data;
    });
 
    run([&]
    {
        CData2 * data2 = new CData2[TEST_COUNT];
            for (int i = 0; i < TEST_COUNT; ++i) {
                data2[i].vec = dist(gen);
            }
 
            delete [] data2;
    });
 
    run([&]{
        CData3 * data3 = new CData3[TEST_COUNT];
            for (int i = 0; i < TEST_COUNT; ++i)
                data3[i].vec.push_back(dist(gen));
            delete [] data3;
    });
 
    return 0;
}
 

C++ (Qt)
auto start = std::chrono::high_resolution_clock::now();
f();
auto stop = std::chrono::high_resolution_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
std::cout << "elapsed time: " << elapsed << " msec" << std::endl;
 

C++ (Qt)
QElapsedTimer t;
t.start();
f();
std::cout << "elapsed time: " << t.elapsed() << " msec" << std::endl;
 

C++ (Qt)
struct CData2 {
    boost::variant<std::vector<float>, float> vec; 
// или boost::variant<std::vector<float>, std::array<float, MAGIC_BUF>> vec; 
// Или написать свою обёртку над таким вариантом, которая внешне была аналогична обычному вектору, например.
};
 

C++ (Qt)
int count;
float * data;   // и просто new[] и delete[]

Bash
elapsed time: 393 msec
elapsed time: 800 msec std::valarray
elapsed time: 5659 msec QList
 

C++ (Qt)
template <size_t num>
struct CData {
 int mValue;
 ...
 float data[num];
};

C++ (Qt)
struct CData {
 int mValue;
 ...
 CVarLengthArray <float, ???> data;  // а здесь что?
};

C++ (Qt)
QVarLengthArray<float> data;

struct S
{
    size_t size;
    union {
        float data1[4];
        float *data2 {nullptr};
    }
};

C++ (Qt)
struct CData {
 size_t size;
 size_t index;  // индекс в др контейнере float
};

C++ (Qt)
struct Data {
 ....
 float *m_data;
};
 

C++ (Qt)
Data data;
data.m_data = FloatAllocator::alloc( 1 );    // Быстро возвращается указатель на буфер в пуле однофлоатов (данные хранятся компактно)
data.m_data = FloatAllocator::alloc( 2 );    // Быстро возвращается указатель на буфер в пуле двуфлоатов (данные хранятся компактно)
data.m_data = FloatAllocator::alloc( 4 );    // Быстро возвращается указатель на буфер в пуле четырехфлоатов (данные хранятся компактно)
data.m_data = FloatAllocator::alloc( 10500 );    // Алоцируется буфер в куче для указанного количества
 
size_t size = FloatAllocator::size( data.m_data );    // Возвращает доступное количество флоатов
 
FloatAllocator::free( data.m_data );    // Для пула просто пометка что буфер освободился, для не преаллоцированых буферов - освобождение
 

C++ (Qt)
template<typename T, size_t maxPrealloc>
class Allocator
{
public:
    T    *alloc( size_t n );
    void  free( T * );
    size_t  size( T * );
};
 

C++ (Qt)
int main()
{
	Allocator<float, 4>	memman;
 
	float *a1 = memman.alloc( 1 );
	BOOST_ASSERT( a1 );
	float *a2 = memman.alloc( 2 );
	BOOST_ASSERT( a2 );
	float *a3 = memman.alloc( 3 );
	BOOST_ASSERT( a3 );
	float *a4 = memman.alloc( 4 );
	BOOST_ASSERT( a4 );
	float *a5 = memman.alloc( 5 );
	BOOST_ASSERT( a5 );
	float *a100 = memman.alloc( 100 );
	BOOST_ASSERT( a100 );
 
	size_t s100 = memman.size( a100 );
	BOOST_ASSERT( s100 == 100 );
	size_t s5 = memman.size( a5 );
	BOOST_ASSERT( s5 == 5 );
	size_t s4 = memman.size( a4 );
	BOOST_ASSERT( s4 == 4 );
	size_t s3 = memman.size( a3 );
	BOOST_ASSERT( s3 == 3 );
	size_t s2 = memman.size( a2 );
	BOOST_ASSERT( s2 == 2 );
	size_t s1 = memman.size( a1 );
	BOOST_ASSERT( s1 == 1 );
 
	memman.free( a2 );
	memman.free( a1 );
	memman.free( a4 );
	memman.free( a3 );
	memman.free( a5 );
	memman.free( a100 );
 
	return 0;
}