C++模板优化

Question

在哪一点上，模板方法的部分将由编译器优化？请问去掉无法访问的代码，去掉不必要的代码循环？ （BITS使用unsigned int类型块，整型使用无符号长的）

另外，有一个C++数据类型，意思是“我是你的处理器登记的大小的整”？

template<size_t bits> class IntegerFactoryImpl : public IntegerFactory<Integer<bits>>{ 
private: 
    template<int sizeOfLong, int sizeOfInt> Integer<bits> getOne(const Bits& b) const{ 

     Integer<bits> integer = this->getOne(); 
     size_t roof = (b.blocks() > integer.size()*(sizeOfLong/sizeOfInt))? integer.size()*(sizeOfLong/sizeOfInt) : b.blocks(); 
     for(size_t i = 0; i < roof; ++i){ 
      integer.at(i/(sizeOfLong/sizeOfInt)) = 0; 
      for(size_t j = 0; j < (sizeOfLong/sizeOfInt); ++j){ 
       if(i % (sizeOfLong/sizeOfInt) == j){ 
        integer.at(i/(sizeOfLong/sizeOfInt)) |= ((unsigned long)b.block(b.blocks()-i-1)) << (sizeOfInt*j); 
        break; 
       } 
      } 
     } 
     for(size_t i = roof; i < integer.size()*(sizeOfLong/sizeOfInt); ++i){ 
      if(i % (sizeOfLong/sizeOfInt) == 0){ 
       integer.at(i/(sizeOfLong/sizeOfInt)) = 0; 
      } 
     } 
     return integer; 
    } 

public: 

    virtual ~IntegerFactoryImpl() throw(){} 

    virtual Integer<bits> getOne() const{ 
     return Integer<bits>(); 
    } 

    virtual Integer<bits> getOne(const Bits& b) const{ 
     return this->getOne<sizeof(unsigned long)*8, sizeof(unsigned int)*8>(b); 
    } 
}; 

会不会有这个代码的差异（没有模板的方法）：

template<size_t bits> class IntegerFactoryImpl : public IntegerFactory<Integer<bits>>{ 

public: 

    virtual ~IntegerFactoryImpl() throw(){} 

    virtual Integer<bits> getOne() const{ 
     return Integer<bits>(); 
    } 

    virtual Integer<bits> getOne(const Bits& b) const{ 

     Integer<bits> integer = this->getOne(); 
     size_t roof = (b.blocks() > integer.size()*((sizeof(unsigned long)/sizeof(unsigned int)))? integer.size()*((sizeof(unsigned long)/sizeof(unsigned int)) : b.blocks(); 
     for(size_t i = 0; i < roof; ++i){ 
      integer.at(i/((sizeof(unsigned long)/sizeof(unsigned int))) = 0; 
      for(size_t j = 0; j < ((sizeof(unsigned long)/sizeof(unsigned int)); ++j){ 
       if(i % ((sizeof(unsigned long)/sizeof(unsigned int)) == j){ 
        integer.at(i/((sizeof(unsigned long)/sizeof(unsigned int))) |= ((unsigned long)b.block(b.blocks()-i-1)) << ((sizeof(unsigned int)*8)*j); 
        break; 
       } 
      } 
     } 
     for(size_t i = roof; i < integer.size()*((sizeof(unsigned long)/sizeof(unsigned int)); ++i){ 
      if(i % ((sizeof(unsigned long)/sizeof(unsigned int)) == 0){ 
       integer.at(i/((sizeof(unsigned long)/sizeof(unsigned int))) = 0; 
      } 
     } 
     return integer; 
    } 
}; 

（编辑：我刚刚发现的代码无法正常工作（我固定它），但原来的问题仍然适用。）

Answer 1

权，编译器将优化掉的东西，它可以在编译时计算，如果你有一个循环，只有一次迭代（如for(i = 0; i < 1; i++)，将彻底消除环路。

至于整数大小，如果使用long或int更好，它取决于你试图达到的目标。例如，在x86-64中，一个64位操作需要一个额外的字节来表示后面的指令是一个64位指令，而不是一个32位指令。如果编译器产生64位长的代码，代码会变得更大一点，因此不适合缓存等。在16,32或64位操作之间没有速度优势[对于99％的操作，乘法和除法是一些明显的例外 - 数字越大，分割或乘法所需的时间就越长（（实际上，数字中SET的位数影响乘法时间，而I相信鸿沟））]在x86-64。当然，例如，如果您使用这些值执行位掩码操作等，则使用long将为您提供64位操作，这些操作只需执行一半操作即可执行相同操作。这显然是一个优势。所以在这种情况下使用long是“正确的”，即使每条指令增加了一个额外的字节。

还要记住，很多时候，int用于“小数字”，所以对很多事情的int额外的尺寸只会被浪费，并采取了额外的数据缓存空间，等等，等等。因此，int仍然保持32位，以保持大整数数组的大小，并且具有合理的大小。