C++ C++；模板优化

在哪一点上，编译器将/可以对模板方法的部分进行优化？它是否会删除无法访问的代码，打开不必要的循环？（位使用无符号整型块，整数使用无符号长整型块）

---

Plus，是否存在C++数据类型，意思是“我是你的处理器注册中心的整数”？< /P>

模板类integerfactorympl:public IntegerFactory{
私人：
模板整数getOne（常量位和b）常量{
整数=此->getOne（）；
size_t roof=（b.blocks（）>integer.size（）*（sizeOfLong/sizeOfInt））？integer.size（）*（sizeOfLong/sizeOfInt）：b.blocks（）；
用于（尺寸i=0；i

此代码（无模板方法）是否会有差异：

模板类integerfactorympl:public IntegerFactory{
公众：
virtual~IntegerFactoryImpl（）throw（）{}
虚拟整数getOne（）常量{
返回整数（）；
}
虚拟整数getOne（常量位和b）常量{
整数=此->getOne（）；
size_t roof=（b.blocks（）>integer.size（）*（（sizeof（无符号长）/sizeof（无符号整数））？integer.size（）*（（sizeof（无符号长）/sizeof（无符号整数））：b.blocks（）；
用于（尺寸i=0；i整数。在（i/（（sizeof（unsigned long）/sizeof（unsigned int）））|=（（unsigned long）b.block（b.blocks（）-i-1））右侧，编译器将优化它可以在编译时计算的内容，如果有一个循环只对（i=0；i<1；i++）

迭代一次，它将完全删除该循环

至于整数大小，这实际上取决于您试图实现的是使用

long

还是

int

更好。例如，在x86-64中，64位操作将需要额外的字节来指示下面的指令是64位指令而不是32位指令。如果编译器使用

int

64位长的话，代码会变大（一点点），因此不太适合缓存等。16、32或64位操作之间没有速度优势[对于99%的操作，乘法和除法是一些明显的例外-数字越大，除法或乘法所需的时间就越长](（实际上，数字中设置的位数会影响乘法时间，我相信除法也会有影响）]在x86-64中。当然，例如，如果您使用值来执行位掩码操作等，则使用

long

将提供64位操作，执行相同操作需要一半的操作。这显然是一个优势。因此它是“正确的”在这种情况下使用

long

，即使它为每条指令添加了额外的字节

---

还要记住，

int

通常用于“较小的数字”因此，对于很多东西，<>代码> int >代码>将被浪费掉，占用额外的数据缓存空间等。因此，代码> int /Cl>仍然保留32位，以保持大整数数组的大小，并且在合理的大小。

你想解决的问题是什么？这是你的解决方案吗？请参阅，有C++数据吗？输入的意思是“我是处理器注册表大小的整数”。Hmmm“int”？不，这是我为正确处理32/64位编译输出而编写的代码，我的问题是：“我必须对每一对组合代码进行编码，还是第一个解决方案（上面）会同样有效？”<代码> int <代码>不能保证与您的寄存器大小相同，但在实践中，它通常与您的“常规”寄存器大小相同。因为您的64位AMD处理器实际上是一个具有64位扩展的x86（32位）架构，所以对于<代码> INT/COM>仍然是有意义的，因为您仍然可以认为这是一个“自然”大小。所以编译器应该知道sizeof（）返回值？另外，在我简单地用（sizeof（xxx）*8）替换（请参见上面的编辑）sizeOfxxx模板参数的情况下，此实现和其他实现之间是否有区别是的，编译器当然知道

sizeof

产生什么。它也知道如何乘、除、加、减整数（通常是浮点）。谢谢。至于性能问题，整数是（事实上）用于多精度算术，我可以说明在AMD64上使用ULONG而不是UINT的性能增益。如果它是x86-64，那么它将能够在32或64位中完成几乎所有事情，速度没有差异，或者任何其他方式的额外指令。有一些例外，但它们几乎可以被忽略。如果您是在节省每最后一个时钟周期，在某些情况下，使用unsigned作为数组索引将保存奇数指令。

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;
    }
};