C 构造函数与初始化列表速度比较

C++ Constructors vs Initialization Lists speed comparison

本文关键字：速度 比较 列表 初始化 构造函数      更新时间：2023-10-16

构造函数和初始化列表之间的执行时间有任何区别吗？（或者只是编码偏好的问题）。我有一组需要经常创建的对象，并且想知道是否使用初始化列表而不是构造函数有任何性能增益。

如果我要创建一百万个级别的A类和B级B级的一百万个实例，那么选择会更好（这些对象代表网络中生成的数据包，因此这些数字）。

 class A {
   private:
     int a, b;
   public:
     A(int a_var, int b_var):a(a_var), b(b_var) {}; 
 };
 class B {
   private:
     int a, b;
   public:
     B(int a_var, int b_var) {
        a = a_var;
        b = b_var;
     }
};

如果任何构造函数比原始类型的其他构造函数快（如示例中的），如果A和B被类型替换吗？

会更快？

类型示例：

 class AType {
   private:
     string a, b;
   public:
     AType(string a_var, string b_var):a(a_var), b(b_var) {}; 
};

差异是针对没有微不足道的默认构造函数的类型，该类型是由类B中的编译器为您拨打的。您的类B等于：

 class B {
   private:
     SleepyInt a, b;
   public:
     // takes at least 20s
     B(int a_var, int b_var) : a(), b()
     //                      ^^^^^^^^^^ 
     {
        a = a_var;
        b = b_var;
     }
  };

如果您不将成员变量或基类构造函数放置在初始化列表中，则默认构造函数为它们。int是基本类型 - 其默认构造函数不花任何成本 - 因此您的示例没有区别，但是对于更复杂的类型构建器 分配可能不仅仅是构造成本。

一些有趣的例子，只是为了说明差异：

class SleepyInt {
public:
  SleepyInt () { 
    std::this_thread::sleep_for(std::chrono::milliseconds( 10000 ));  
  }
  SleepyInt (int i) {}
  SleepyInt & operator = (int i) { return *this; }
};
class A {
   private:
     SleepyInt a, b;
   public:
     A(int a_var, int b_var):a(a_var), b(b_var) {}; 
 };
 class B {
   private:
     SleepyInt a, b;
   public:
     // takes at least 20s
     B(int a_var, int b_var) {
        a = a_var;
        b = b_var;
     }
};

使用初始化列表而不是在构造函数中进行分配是通常接受的实践，这是一个很好的理由。

初始化列表可用于初始化POD（普通旧数据）和用户定义的类型。初始化POD类型时，效果与分配运算符完全相同，这意味着在POD类型的构造函数中初始化列表或分配之间没有性能差异。

当我们考虑非POD类型时，事情变得更加有趣。在调用构造函数之前，请调用父类，然后调用任何包含的成员，默认情况下，no-argument构造函数被调用。使用初始化列表，您可以选择称为哪个构造函数。

为了回答这个问题，存在性能差异，但只有在初始化非POD类型时。

如果成员的类型或多或少是复杂的类型，则分配初始化将首先导致默认构造函数调用，然后引起operator=，然后可能需要更长的时间。

如果类型是内置/内在类型，则不会进行性能改进。

也就是说：

结论：所有其他情况相等，如果您的代码运行速度将更快 您使用初始化列表而不是分配。

初始化列表是有益的参考类型，成员类对象或const成员。否则需要更多的时间。

查看我的测试代码：

#include <iostream>
#include <ctime>
using namespace std;
class A{
    int a;
public:
    A(int a_):a(a_){}
};
class B{
    int b;
public:
    B(){
    }
    B(int b_){
        b=b_;
    }
};
class C{
    B b;
public:
    C(int c_):b(c_){
    }
};
class D{
    B b;
public:
    D(int d_){
        b=d_;
    }
};
int main()
{
    clock_t start1[10], start2[10], end1[10], end2[10];
    for(int j=0;j<10;j++){
        start1[j]=clock();
        for(int i=0;i<100000;i++){   
            A *newA=new A(i);
            delete newA;
        }
        end1[j]=clock();
        start2[j]=clock();
        for(int i=0;i<100000;i++){   
            B *newB=new B(i);
            delete newB;
        }
        end2[j]=clock();
    }
    double avg1=0, avg2=0;
    for(int i=0;i<10;i++){
        avg1+=(end1[i]-start1[i]);
        avg2+=(end2[i]-start2[i]);
    }
    cout << avg1/avg2 << endl;
    for(int j=0;j<10;j++){
        start1[j]=clock();
        for(int i=0;i<100000;i++){   
            C *newC=new C(i);
            delete newC;
        }
        end1[j]=clock();
        start2[j]=clock();
        for(int i=0;i<100000;i++){   
            D *newD=new D(i);
            delete newD;
        }
        end2[j]=clock();
    }
    avg1=avg2=0;
    for(int i=0;i<10;i++){
        avg1+=(end1[i]-start1[i]);
        avg2+=(end2[i]-start2[i]);
    }
    cout << avg1/avg2 << endl;
    system("pause");
    return 0;
}



这样的示例输出：

1.02391
0.934741

相关文章：