Russian Qt Forum

C++ (Qt)
#include <vector>
 
int main()
{
    std::vector<int> arr( 10, 0 );
 
    return 0;
}
 

C++ (Qt)
#include <vector>
 
int main()
{
    std::vector<float> arr( 10, 0.0f );
 
    return 0;
}
 

C++ (Qt)
#include <vector>
 
int main()
{
    std::vector<double> arr( 10, 0.0 );
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> arr( 10, 0);
 
    arr[0] = 34;
    arr[1] = 5;
 
    std::cout << arr[0] << std::endl;
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> arr( 10, 0);
 
    arr[0] = 34;
    arr[1] = 5;
 
    std::cout << "size = " << arr.size() << std::endl; // output: size = 10
 
    arr.push_back( 87 );
    std::cout << arr[10] << std::endl; // output: 87
 
    std::cout << "size = " << arr.size() << std::endl; // output: size = 11
 
    return 0;
}
 

C++ (Qt)
#include <vector>
 
int main()
{
    std::vector< std::vector<int> > arr( 5 );
 
    return 0;
}
 

C++ (Qt)
#include <vector>
 
int main()
{
    const int nrows = 5;
    const int ncols = 3;
 
    std::vector< std::vector<int> > arr( nrows );
 
    for( size_t row = 0; row < nrows; ++row ) {
        arr[row].resize( ncols );
    }
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
#include <vector>
 
int main()
{
    const int nrows = 5;
    const int ncols = 3;
 
    std::vector< std::vector<int> > arr( nrows );
 
    for( size_t row = 0; row < nrows; ++row ) {
        arr[row].resize( ncols );
    }
 
    arr[4][0] = 87;
 
    std::cout << arr[4][0] << std::endl;
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
#include <vector>
 
void show1DArray( const std::vector<int> &arr1D )
{
    std::cout << arr1D[0] << std::endl;
}
 
void show2DArray( const std::vector< std::vector<int> > &arr2D )
{
    std::cout << arr2D[1][1] << std::endl;
}
 
int main()
{
    // 1D array
    std::vector<int> arr1D( 10, 0);
 
    arr1D[0] = 34;
 
    show1DArray( arr1D );
 
    const int nrows = 5;
    const int ncols = 3;
 
    // 2D array
    std::vector< std::vector<int> > arr2D( nrows );
 
    for( size_t row = 0; row < nrows; ++row ) {
        arr2D[row].resize( ncols );
    }
 
    arr2D[1][1] = 5;
 
    show2DArray( arr2D );
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
#include <vector>
 
void show1DArray( int *p )
{
    std::cout << p[0] << std::endl;
}
 
int main()
{
    // 1D array
    std::vector<int> arr1D( 10, 0);
 
    arr1D[0] = 34;
 
    show1DArray( arr1D.data() );
 
    return 0;
}
 

C++ (Qt)
    std::vector<GLfloat> m_vertices;
    std::vector<GLfloat> m_textures;
    std::vector<GLuint> m_indices;
 
    // ...
 
    m_vertices.push_back( -50.0f );    //X
    m_vertices.push_back( -50.0f );    //Y
    m_vertices.push_back( 0.0f );      //Z
 
    m_vertices.push_back( 50.0f );     //X
    m_vertices.push_back( -50.0f );    //Y
    m_vertices.push_back( 0.0f );      //Z
 
    m_vertices.push_back( 50.0f );     //X
    m_vertices.push_back( 50.0f );     //etc..
    m_vertices.push_back( 0.0f );
 
    // ...
 
    glVertexPointer( 3, GL_FLOAT, 0, m_vertices.data() );
    glTexCoordPointer( 2, GL_FLOAT, 0, m_textures.data() );
    // ...
 

C++ (Qt)
int arr[10]
 

C++ (Qt)
std::vector<int> arr(10);
 

C++ (Qt)
std::vector<int> arr;
arr.resize( 10 );
 

C++ (Qt)
#include <iostream>
#include <memory>
 
struct Person
{
    std::string firstName;
    std::string lastName;
};
 
int main()
{
    // Create object
    auto p = std::make_shared<Person>();
 
    // Use object
    p->firstName = "Ivan";
    std::cout << p->firstName << std::endl;
 
    return 0;
}
 

C++ (Qt)
#include <iostream>
 
struct Person
{
    std::string firstName;
    std::string lastName;
};
 
int main()
{
    // Create object
    Person *p = new Person;
 
    // Use object
    p->firstName = "Ivan";
    std::cout << p->firstName << std::endl;
 
    // Delete object
    delete p;
 
    return 0;
}
 

C++ (Qt)
    std::vector< std::vector<int> > arr( 5 );
 

C++ (Qt)
int * a = &vec[0];
 

C++ (Qt)
// The fullscreen quad's FBO
GLuint quad_VertexArrayID;
glGenVertexArrays(1, &quad_VertexArrayID);
glBindVertexArray(quad_VertexArrayID);
 
static const GLfloat g_quad_vertex_buffer_data[] = {
    -1.0f, -1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
     1.0f,  1.0f, 0.0f,
};
 
GLuint quad_vertexbuffer;
glGenBuffers(1, &quad_vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
 

C++ (Qt)
// The fullscreen quad's FBO
GLuint quad_VertexArrayID;
glGenVertexArrays(1, &quad_VertexArrayID);
glBindVertexArray(quad_VertexArrayID);
 
typedef std::vector<float> test_container ;
//typedef std::array<float,18> test_container ;
 
static const test_container g_quad_vertex_buffer_data = {
    -1.0f, -1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
     1.0f,  1.0f, 0.0f,
};
 
GLuint quad_vertexbuffer;
glGenBuffers(1, &quad_vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, g_quad_vertex_buffer_data.size(), g_quad_vertex_buffer_data.data(), GL_STATIC_DRAW);

C++ (Qt)
 
// QHash.cpp
      if (numBuckets) {
        QT_TRY {
            d->buckets = new Node *[numBuckets];
        } QT_CATCH(...) {
 

C++ (Qt)
/*******************************************************************************
*  file    :
*  created : 30.10.2014
*  author  :
*******************************************************************************/
 
#include <iostream>
#include <vector>
#include <array>
#include <chrono>
 
#include <cstdint>
 
using namespace std::chrono;
 
template<class T, uint32_t N >
inline uint32_t ARRAY_SIZE(T (&)[N]) {return N;}
 
static const float g_quad_vertex_buffer_data[] = {
    -1.0f, -1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
     1.0f,  1.0f, 0.0f,
};
 
static const std::vector<float> v = {
    -1.0f, -1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
     1.0f,  1.0f, 0.0f,
};
 
static const std::array<float, 18> a = {
    -1.0f, -1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
    -1.0f,  1.0f, 0.0f,
     1.0f, -1.0f, 0.0f,
     1.0f,  1.0f, 0.0f,
};
 
double make_sum(const float* data, std::size_t sz);
 
template <typename T>
double make_sum_inl(const T& vec)
{
    double res = 0.;
    for(std::size_t i = 0; i < vec.size(); ++i)
        res += vec.at(i);
 
    return res;
}
 
double make_sum_inl(const float* data, std::size_t sz)
{
    double res = 0.;
    for(std::size_t i = 0; i < sz; ++i)
        res += data[i];
 
    return res;
}
 
int main(int argc, char* argv[])
{
    std::cout << "Hello ..." << std::endl;
 
    std::cout << "Sum 1 =  " << make_sum(g_quad_vertex_buffer_data,ARRAY_SIZE(g_quad_vertex_buffer_data)) << std::endl;
    std::cout << "Sum 2 =  " << make_sum(v.data(),v.size()) << std::endl;
 
    static const uint64_t iter_cnt = 100000000;
 
    {
        high_resolution_clock::time_point t1 = high_resolution_clock::now();
        volatile double s;
        const std::size_t add_sz = ARRAY_SIZE(g_quad_vertex_buffer_data);
        for(uint64_t i = 0; i < iter_cnt; i ++)
            s = make_sum(g_quad_vertex_buffer_data, add_sz);
        high_resolution_clock::time_point t2 = high_resolution_clock::now();
 
        std::cout << "C array (noinline)\t ";
        std::cout << duration_cast<nanoseconds>(t2 - t1).count() ;
        std::cout << std::endl;
    }
 
    {
        high_resolution_clock::time_point t1 = high_resolution_clock::now();
        volatile double s;
        for(uint64_t i = 0; i < iter_cnt; i ++)
            s = make_sum(v.data(),v.size());
        high_resolution_clock::time_point t2 = high_resolution_clock::now();
 
        std::cout << "Vector  (noinline)\t " ;
        std::cout << duration_cast<nanoseconds>(t2 - t1).count() ;
        std::cout << std::endl;
    }
 
    {
        high_resolution_clock::time_point t1 = high_resolution_clock::now();
        volatile double s;
        for(uint64_t i = 0; i < iter_cnt; i ++)
            s = make_sum(a.data(),a.size());
        high_resolution_clock::time_point t2 = high_resolution_clock::now();
 
        std::cout << "Array   (noinline)\t " ;
        std::cout << duration_cast<nanoseconds>(t2 - t1).count() ;
        std::cout << std::endl;
    }
//======================================================================================================
 
    {
        high_resolution_clock::time_point t1 = high_resolution_clock::now();
        volatile double s;
        const std::size_t add_sz = ARRAY_SIZE(g_quad_vertex_buffer_data);
        for(uint64_t i = 0; i < iter_cnt; i ++)
            s = make_sum_inl(g_quad_vertex_buffer_data,add_sz);
        high_resolution_clock::time_point t2 = high_resolution_clock::now();
 
        std::cout << "C array (inline)\t " ;
        std::cout << duration_cast<nanoseconds>(t2 - t1).count() ;
        std::cout << std::endl;
    }
 
    {
        high_resolution_clock::time_point t1 = high_resolution_clock::now();
        volatile double s;
        for(uint64_t i = 0; i < iter_cnt; i ++)
            s = make_sum_inl(v);
        high_resolution_clock::time_point t2 = high_resolution_clock::now();
 
        std::cout << "Vector  (inline)\t " ;
        std::cout << duration_cast<nanoseconds>(t2 - t1).count() ;
        std::cout << std::endl;
    }
 
    {
        high_resolution_clock::time_point t1 = high_resolution_clock::now();
        volatile double s;
        for(uint64_t i = 0; i < iter_cnt; i ++)
            s = make_sum_inl(a.data(),a.size());
        high_resolution_clock::time_point t2 = high_resolution_clock::now();
 
        std::cout << "Array   (inline)\t " ;
        std::cout << duration_cast<nanoseconds>(t2 - t1).count() ;
        std::cout << std::endl;
    }
 
    return 0;
}
 
__attribute__((noinline)) double make_sum(const float* data, std::size_t sz)
{
    double res = 0.;
    for(std::size_t i = 0; i < sz; ++i)
        res += data[i];
 
    return res;
}
 
 

C++ (Qt)
template <typename T>
double make_sum_inl( const T& vec)
{
    double res = 0.;
//    for(std::size_t i = 0; i < vec.size(); ++i)
//       res += vec.at(i);
 
	for (auto it : vec)
		res += it;
 
    return res;
}
 

C++ (Qt)
#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
#include <algorithm>
#include <iterator>
 
template <typename Type>
std::vector<Type> getArrya( std::size_t n );
 
template <typename Type>
void showArray( const std::vector<Type> &arr );
 
int main()
{
    // Get size
    std::cout << "Enter a size for the array: ";
    size_t n;
    std::cin >> n;
 
    // Get array
    std::vector<int> arr;
    arr = getArrya<int>( n );
 
    // Before
    std::cout << "Before: " << std::endl;
    showArray( arr );
 
    // Sort
    std::sort( arr.begin(), arr.end(), []( int i , int j ) { return i > j; } );
 
    // After
    std::cout << "After: " << std::endl;
    showArray( arr );
    std::cout << std::endl;
 
    return 0;
}
 
template <typename Type>
std::vector<Type> getArrya( std::size_t n )
{
    std::vector<int> arr( n );
    std::srand( std::time( NULL ) );
    std::transform( arr.begin(), arr.end(), arr.begin(),
                    []( Type i ) { return std::rand() % 100; } );
    return arr;
}
 
template <typename Type>
void showArray( const std::vector<Type> &arr )
{
    std::copy( arr.begin(), arr.end(),
               std::ostream_iterator<Type>( std::cout, " " ) );
    std::cout << std::endl;
}