将空向量聚合或合并为最大的空向量？ 我有一个C++头标题模板类，它使用一个空向量（0的字符串）。字符串的长度由模板参数决定（它是一个实现，长度取决于基础哈希摘要大小） 模板 香港迪士尼乐园 { ... 私人： typedef byte NullVector[HASH:：DIGESTSIZE]； 静态常数nullvec； };

可以聚合各种

NullVector

，所有实例化的类都可以使用最大摘要大小的

NullVector

。例如，MD5具有16字节的摘要大小，而SHA-512具有64字节的摘要大小。因此，工具链可以生成一个64字节的向量，然后所有类，如MD5、SHA-1、Whirlpool和SHA-512都可以使用它

这类似于字符串池，但我不希望编译器或链接器进行这种观察或看到这种模式（但我可能错了）。所以我想给这些工具一个提示

是否可以告诉编译器或链接器聚合或汇集

NullVectors

，并且只输出最终二进制文件中的最大值？如果是，怎么做

我经常与MSVC、GCC、ICC和Clang合作。我对GCC兼容的编译器特别感兴趣，因为它涵盖了大多数用例。因此，如果需要，我很乐意使用特定于GCC的扩展

---

这里有更多的背景故事。。。迭代散列，如MD5、SHA1到SHA512和Whirlpool有固定的块大小。对于这些散列，共享一个0的64字节数组应该可以。我从未见过块大小大于64字节的迭代哈希，但我需要注意它

递归散列，如SHA-3，本身没有块大小。我甚至不知道如何使经典的HMAC和HKDF在SHA3和其他递归哈希中工作

---

不过，您可以使用迭代和递归散列来做相同的事情。你显然可以理解一条信息。但作为一个更复杂的例子，由于扩展攻击，HMAC必须将

ipad

和

opad

添加到迭代哈希中，但您可以生成密钥摘要或身份验证标记。对于递归散列，只需将密钥与消息连接起来，以生成带密钥的摘要或auth标记。不需要使用递归散列进行内部或外部填充。

这里有一个可能的解决方案，可以让您更接近，但您仍然需要确定最大大小应该是多少：

编辑：由于

c++03

标记而更新。以前的代码需要c++11

#include <cassert>
#include <cstdlib>

struct NullContainer                                                            
{                                                                               
    static const size_t LARGEST_SIZE = 1024 ;                               
    typedef unsigned char LargeNullVector[LARGEST_SIZE] ;                             
    static const LargeNullVector m_vec ;                                        
} ;             

const NullContainer::LargeNullVector NullContainer::m_vec = {0} ;

template < class HASH >                                                         
class HKDF : public NullContainer                                               
{                                                                               
} ;                                                                                              

int main()                                                                      
{                                                                               
    assert( &HKDF<int>::m_vec == &HKDF<char>::m_vec ) ;                         
    return 0;                                                                   
}   

#包括
#包括
结构空容器
{                                                                               
静态常量大小\u t最大\u大小=1024；
typedef unsigned char LargeNullVector[最大大小]；
静态常量向量m_向量；
} ;             
常量NullContainer:：LargeNullVector NullContainer:：m_vec={0}；
模板<类哈希>
HKDF类：公共容器
{                                                                               
} ;                                                                                              
int main（）
{                                                                               
断言（&HKDF:：m_vec==&HKDF:：m_vec）；
返回0；
}   

---

当然，您可能希望在这种情况下使用。

这里有一个可能的解决方案，可以让您更接近，但您仍然需要决定最大尺寸应该是多少：

编辑：由于

c++03

标记而更新。以前的代码需要c++11

#include <cassert>
#include <cstdlib>

struct NullContainer                                                            
{                                                                               
    static const size_t LARGEST_SIZE = 1024 ;                               
    typedef unsigned char LargeNullVector[LARGEST_SIZE] ;                             
    static const LargeNullVector m_vec ;                                        
} ;             

const NullContainer::LargeNullVector NullContainer::m_vec = {0} ;

template < class HASH >                                                         
class HKDF : public NullContainer                                               
{                                                                               
} ;                                                                                              

int main()                                                                      
{                                                                               
    assert( &HKDF<int>::m_vec == &HKDF<char>::m_vec ) ;                         
    return 0;                                                                   
}   

#包括
#包括
结构空容器
{                                                                               
静态常量大小\u t最大\u大小=1024；
typedef unsigned char LargeNullVector[最大大小]；
静态常量向量m_向量；
} ;             
常量NullContainer:：LargeNullVector NullContainer:：m_vec={0}；
模板<类哈希>
HKDF类：公共容器
{                                                                               
} ;                                                                                              
int main（）
{                                                                               
断言（&HKDF:：m_vec==&HKDF:：m_vec）；
返回0；
}   

---

当然，您可能希望在这种情况下使用。

那么您想要的是自定义分配器吗？不是您定义模板的方式。请注意，每次使用不同类型（

HASH

）实例化模板时，都会创建一个新的静态

m_-vec

。因此，如果

Hash1

和

Hash2

是不同的类型，

HKDF

和

HKDF

将不会共享

m_-vec

。您基本上只想在整个应用程序中拥有一个最大大小的NullVector实例（顺便说一句，名称很奇怪。它不是通常理解的向量）？“您基本上只希望有一个NullVector实例”-是的。没有理由在BSS中为

HKDF

设置一个0字符串，在BSS中为

HKDF

设置一个不同的0字符串，还有另一个stri