Russian Qt Forum

C++ (Qt)
std::vector <QPoint3D> mPoint;  // котейнер точек
typedef int Triangle[3];
std::vector <Triangle> mTriangle;  // контейнер треугольников
 

C++ (Qt)
std::vector <Triangle> mTriangle = { { 1, 2, 3 }, {4, 5, 6 } };
 

C++ (Qt)
typedef std::array<int, 3> Triangle;
 

C++ (Qt)
    int arr[10][3] = { {1, 2, 3 }, {4, 5, 6 }, {}, {}, {}, {}, {}, {}, {}, {} };   
   std::vector<std::array<int,3>> tr = { {1, 2, 3 }, {4, 5, 6 }, {}, {}, {}, {}, {}, {}, {}, {} };

C++ (Qt)
    int arr[10][3] = { {1, 2, 3 }, {4, 5, 6 }, {}, {}, {}, {}, {}, {}, {}, {} };   
   std::vector<std::array<int,3>> tr = { {1, 2, 3 }, {4, 5, 6 }, {}, {}, {}, {}, {}, {}, {}, {} };

C++ (Qt)
std::vector<std::array<int,3>> tr = { {{1, 2, 3 }}, {{4, 5, 6 }} };
 

C++ (Qt)
typedef int Triangle[3];
std::vector <Triangle> mTriangle;  // контейнер треугольников

C++ (Qt)
int array[1000];
int v = array[ 50 ];
// off = 50 * sizeof( int );
// addr_50 = &array + off;
 

C++ (Qt)
int array[1000];
int v = array[ 50 ];
// off = 50 * sizeof( int );
// addr_50 = &array + off;
 

C++ (Qt)
*(array + 50)

C++ (Qt)
int v = 50[array]

C++ (Qt)
void DoCopy( const int * src, int * dst, int count )
{
 const int * end = src + count;
 while (src != end) {
  *dst = *src;   // *(dst++) = *(src++);
   ++src;
   ++dst;
 }
}
 

C++ (Qt)
void Widget::on_test2_clicked()
{
    std::vector<int> tmp;
    int i = 0;
    tmp.resize(1000000);
 
    std::vector<int>::iterator it = tmp.begin();
    QTime timer;
    timer.start();
    for (int m = 0; m < 10000; ++m)
    {
        for(; it != tmp.end(); ++it)
        {
            (*it) = i + 1;
            ++i;
        }
        it = tmp.begin();
        for(; it != tmp.end(); ++it)
        {
            i = (*it);
        }
    }
    ui->label_2->setText(QString::number(timer.elapsed()));
 
 
}
 
void Widget::on_pushButton_clicked()
{
    std::vector<int> tmp;
    int j = 0;
    tmp.resize(1000000);
    QTime timer;
    timer.start();
    for (int m = 0; m < 10000; ++m)
    {
        size_t i = 0;
        for (; i < 1000000; ++i)
        {
            tmp[i] = j + 1;
            ++j;
        }
        i = 0;
        for (; i < 1000000; ++i)
        {
            j = tmp[i];
        }
    }
    ui->label->setText(QString::number(timer.elapsed()));
}
 

C++ (Qt)
void DoCopy( const int * src, int * dst, int count )
{
 const int * end = src + count;
 while (src != end) {
  *dst = *src;   // *(dst++) = *(src++);
   ++src;
   ++dst;
 }
}

C++ (Qt)
void DoCopy( const int * src, int * dst, int count )
{
  for( size_t i = 0; i < count; ++i )
     dst[ i ] = src[ i ];
}

C++ (Qt)
#include <vector>
#include <cstdio>
 
struct Point3D {
  double x, y, z;
};
 
struct Triangle {
  int v[3];
};
 
typedef std::vector<Point3D> Points;
typedef std::vector<Triangle> Triangles;
typedef std::vector<int> Indexes;
 
void remove_points(Points &points, Triangles &triangles, const Indexes &remove)
{
  size_t sz = points.size();
  // create map for points indexes
  Indexes map(sz);
  // mapping to -1 means removed
  for (size_t i = 0; i < remove.size(); ++i) {
    map[remove[i]] = -1;
  }
  // compute mapping and update points
  size_t count = 0;
  for (size_t i = 0; i < sz; ++i) {
     if (map[i] != -1) {
       map[i] = count;
       points[count++] = points[i];
     }
  }
  points.resize(count);
  // update triangles
  count = 0;
  for (size_t i = 0; i < triangles.size(); ++i) {
    Triangle &t = triangles[i];
    bool removed = false;
    for (size_t j = 0; j < 3; ++j) {
      int u = map[t.v[j]];
      if (u == -1) {
        removed = true;
        break;
      }
      t.v[j] = u;
    }
    if (!removed) {
      triangles[count++] = t;
    }
  }
  triangles.resize(count);
}
 
void print(const char* str, const Triangles &triangles)
{
  std::printf("%s:", str);
  for (size_t i = 0; i < triangles.size(); ++i) {
    const Triangle & t = triangles[i];
    std::printf("%s(%d, %d, %d)", (i % 3 ? ", " : "\n  "), t.v[0], t.v[1], t.v[2]);
  }
  std::printf("\n\n");
}
 
int main()
{
  Points pts = { {0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 1, 1}, {2, 2, 2} };
  Triangles trs = { {{0, 1, 2}}, {{0, 2, 3}}, {{2, 3, 1}}, {{2, 4, 3}},
                   {{4, 3, 1}}, {{4, 2, 3}}, {{0, 2, 4}}, {{0, 1, 4}},
                   {{5, 2, 1}}, {{5, 4, 3}}, {{0, 2, 5}}, {{1, 3, 5}}, };
  Indexes ids = { 0, 2 };
  print("Before", trs);
  remove_points(pts, trs, ids);
  print("After", trs);
}
 

C++ (Qt)
std::list<int> src;
MyCollection dst;
 
for( int i = 0; i < src.size(); ++i )
    dst[ i ] = src[ i ];
 

C++ (Qt)
typedef std::vector<int>::iterator iter;
for( iter i = col.begin(); i != col.end(); ++i )
{
}
 
for(auto i = col.begin(); i != col.end(); ++i )
{
}
 
for( auto i : col )
{
}
 

C++ (Qt)
a[i] = 44;
 

ASM
movl $44, 4(%esp)
 

ASM
L2:
	movl	%ebx, 4(%esp) ; array[i] = i
	addl	$1, %ebx      ; i++
	movl	$LC0, (%esp)
	call	_printf       ; printf("%d\n", i)
	cmpl	$10, %ebx     ; i < 10
	jne	L2
 

C++ (Qt)
 
 
#include <iostream>
#include <vector>
#include <array>
#include <algorithm>
#include <functional>
#include <random>
#include <chrono>
 
template <class T = int>
struct point
{
    typedef T pt;
    point(T x_ = T(), T y_ = T(), T z_ = T()):x(x_),y(y_),z(z_){}
    T x, y, z ;
};
 
typedef point<double> Point3D;
typedef std::array<int,3>    Triangle;
 
std::vector<Point3D>  mPoint;  // котейнер точек
std::vector<Triangle> mTriangle;  // контейнер треугольников
 
#define NUM_POINT	(100 * 100000)
#define NUM_TRIA	(100 * 100000)
 
int main()
{
    mPoint.resize(NUM_POINT);
    mTriangle.resize(NUM_TRIA);
    std::generate(mPoint.begin(),mPoint.end(),
                  []()->Point3D{static typename Point3D::pt i = 0; i++; return Point3D(i,i,i);});
 
    std::mt19937 gen;
    gen.seed(std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()));
    std::uniform_int_distribution<int> dist(0, NUM_POINT - 1);
    std::generate(mTriangle.begin(),mTriangle.end(),
                  [&]()->Triangle{Triangle res;for(int& i : res) {i = dist(gen);} return res;});
 
    std::vector<int> need_del_point = {2, 12, 24, 37, 42, 55, 69, 75, 84, 93 };
    std::cout<<"Need delete:"<<std::endl;
    for( int i : need_del_point)
        std::cout<<i<<" ";
    std::cout<<std::endl;
 
    std::sort(need_del_point.begin(),need_del_point.end());
 
    auto print_tr = [&](const std::string& msg, size_t cnt)->void
    {
        size_t pnt_cnt = (cnt > mTriangle.size()) ? mTriangle.size() : cnt ;
        if(pnt_cnt)
            std::cout<<msg<<std::endl;
        for(size_t idx = 0; idx < pnt_cnt; ++idx)
            {
                std::cout<<"("<<mTriangle[idx][0]<<","
                              <<mTriangle[idx][1]<<","
                              <<mTriangle[idx][2]<<")";
                if( ((idx+1) % 3) == 0 )
                    std::cout<<std::endl;
                else
                    std::cout<<"\t";
            }
        std::cout<<std::endl;
    };
 
    print_tr("After:", 10);
    auto start_time = std::chrono::high_resolution_clock::now();
    //std::vector<Triangle> tmp_triangle(mTriangle.size());
    struct ModTriangle : public std::binary_function<Triangle,std::vector<int>,Triangle>
    {
        Triangle operator() (const Triangle& t, const std::vector<int>& del_pt)
        {
            Triangle res;
            for(size_t i = 0; i < t.size(); ++i)
                {
                    if(std::binary_search(del_pt.begin(),del_pt.end(),t.at(i)))
                        {
                            res[0] = -1;
                            break;
                        }
                    else
                        {
                            auto it = std::upper_bound(del_pt.begin(),del_pt.end(),t.at(i));
                            res[i] = t.at(i) - std::distance(del_pt.begin(), it);
                        }
 
                }
            return res;
        }
    };
 
    std::transform(mTriangle.begin(),mTriangle.end(),mTriangle.begin(),
                   std::bind(ModTriangle(),std::placeholders::_1,need_del_point));
    auto copy_end = std::copy_if(mTriangle.begin(),mTriangle.end(),mTriangle.begin(),
                                 [](const Triangle& t){return (t[0] >= 0);});
    mTriangle.resize(std::distance(mTriangle.begin(), copy_end));
 
    auto copy_pt_end = std::copy_if(mPoint.begin(),mPoint.end(),mPoint.begin(),
            [&](const Point3D& )->bool
           { static int i = 0;
             return (! std::binary_search(need_del_point.begin(), need_del_point.end(), i++));
           });
    mPoint.resize(std::distance(mPoint.begin(),copy_pt_end));
 
    auto end_time = std::chrono::high_resolution_clock::now();
    print_tr("Before:", 10);
    std::cout<<"------------------------------------------------------------------"<<std::endl;
    std::cout<<"deleted points    = "<<NUM_POINT - mPoint.size()<<std::endl;
    std::cout<<"deleted triangles = "<<NUM_TRIA  - mTriangle.size()<<std::endl;
    std::cout<<"test duration : ";
    std::cout << std::chrono::duration_cast<std::chrono::seconds>(end_time - start_time).count() << ".";
    std::cout << std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count() << "s.";
    std::cout<<std::endl;
    return 0;
}
 

C++ (Qt)
    auto print_tr = [&](const std::string& msg, size_t cnt)->void
    {
        size_t pnt_cnt = (cnt > mTriangle.size()) ? mTriangle.size() : cnt ;
        if(pnt_cnt)
            std::cout<<msg<<std::endl;
        for(auto idx = mTriangle.begin(); std::distance(mTriangle.begin(), idx) < pnt_cnt; ++idx)
            {
                std::cout<<"("<<(*idx)[0]<<","
                              <<(*idx)[1]<<","
                              <<(*idx)[2]<<")";
                if( ((std::distance(mTriangle.begin(), idx)+1) % 3) == 0 )
                    std::cout<<std::endl;
                else
                    std::cout<<"\t";
            }
        std::cout<<std::endl;
    };

C++ (Qt)
// mark	deleted points with -1
	for (i = 0; i < delIndex.size(); ++i) 
		tmp[delIndex[i]] = -1;
 

C++ (Qt)
std::vector<int> need_del_point = {2, 2, 12, 24, 37, 42, 55, 69, 75, 84, 93 };

C++ (Qt)
std::vector<int> need_del_point = {2, 2, 12, 24, 37, 42, 55, 69, 75, 84, 93 };

C++ (Qt)
typedef std::vector <int> TIntVec;
 
// returns -1 if index is deleted, otherwise a new index
int RemapIndex( int index, const TIntVec & vec )
{
	TIntVec::const_iterator it = std::lower_bound(vec.begin(), vec.end(), index);
	if (it == vec.end()) return index - vec.size();
	if (*it == index) return -1;
	return index - std::distance(vec.begin(), it);
}