在C++/G++中，是否有*任何*方法可以获得C样式数组的长度

我已经尝试实现lengthof（T*v）函数很长一段时间了，但到目前为止没有任何成功。

对于Tv[n]数组，有两种基本的、众所周知的解决方案，一旦数组衰减为T*v指针，这两种解决方案都是无用的，甚至是危险的。

#define SIZE(v) (sizeof(v) / sizeof(v[0]))
template <class T, size_t n>
size_t lengthof (T (&) [n])
{
    return n;
}

有一些涉及包装类和容器的变通方法，如STLSoft的arrayproxy、boost:：array、std:：vector等。所有这些方法都有缺点，缺乏数组的简单性、语法优势和广泛使用。

当delete[]需要知道数组的长度时，编译器通常会使用涉及编译器特定调用的解决方案。根据C++FAQ Lite 16.14，编译器使用两种技术来确定要释放多少内存：过度分配和关联数组。在超分配时，它会多分配一个字大小，并将数组的长度放在第一个对象之前。另一种方法显然将长度存储在关联数组中。是否可以知道G++使用哪种方法，并提取适当的数组长度？开销和衬垫怎么办？对非编译器特定的代码有希望吗？甚至是非平台特定的G++内置？

还有一些解决方案涉及重载运算符new[]和运算符delete[]，我实现了它们：

std::map<void*, size_t> arrayLengthMap;
inline void* operator new [] (size_t n)
throw (std::bad_alloc)
{
    void* ptr = GC_malloc(n);
    arrayLengthMap[ptr] = n;
    return ptr;
}
inline void operator delete [] (void* ptr)
throw ()
{
    arrayLengthMap.erase(ptr);
    GC_free(ptr);
}
template <class T>
inline size_t lengthof (T* ptr)
{
    std::map<void*, size_t>::const_iterator it = arrayLengthMap.find(ptr);
    if( it == arrayLengthMap.end() ){
        throw std::bad_alloc();
    }
    return it->second / sizeof(T);
}

它一直工作得很好，直到我遇到一个奇怪的错误：lengthof找不到数组。事实证明，G++在这个特定数组的开头分配的字节比它应该分配的多了8个。尽管运算符new[]应该返回整个数组的开头，但调用它ptr，调用代码得到的却是ptr+8，因此lengthof（ptr+8）显然失败了，并出现了异常（即使没有，它也可能返回错误的数组大小）。这8个字节是某种开销还是填充？不能是前面提到的过度分配，该函数对许多数组都能正确工作。它是什么？假设可以使用G++特定的调用或欺骗，如何禁用或解决它？

编辑：由于可以通过多种方式分配C样式数组，因此通常不可能像Oli Charlesworth建议的那样，通过指针来判断任意数组的长度。但是，根据Ben Voigt:的想法，对于未衰减的静态数组（请参阅上面的模板函数），以及使用自定义运算符new[]（size_t，size_t）分配的数组，也是可能的

#include <gc/gc.h>
#include <gc/gc_cpp.h>
#include <iostream>
#include <map>
typedef std::map<void*, std::pair<size_t, size_t> > ArrayLengthMap;
ArrayLengthMap arrayLengthMap;
inline void* operator new [] (size_t size, size_t count)
throw (std::bad_alloc)
{
    void* ptr = GC_malloc(size);
    arrayLengthMap[ptr] = std::pair<size_t, size_t>(size, count);
    return ptr;
}
inline void operator delete [] (void* ptr)
throw ()
{
    ArrayLengthMap::const_iterator it = arrayLengthMap.upper_bound(ptr);
    it--;
    if( it->first <= ptr and ptr < it->first + it->second.first ){
        arrayLengthMap.erase(it->first);
    }
    GC_free(ptr);
}
inline size_t lengthof (void* ptr)
{
    ArrayLengthMap::const_iterator it = arrayLengthMap.upper_bound(ptr);
    it--;
    if( it->first <= ptr and ptr < it->first + it->second.first ){
        return it->second.second;
    }
    throw std::bad_alloc();
}
int main (int argc, char* argv[])
{
    int* v = new (112) int[112];
    std::cout << lengthof(v) << std::endl;
}

不幸的是，由于编译器的任意开销和填充，到目前为止，没有可靠的方法来确定自定义运算符new[]（size_t）中动态数组的长度，除非我们假设填充小于数组中一个元素的大小。

然而，正如Ben Voigt所建议的，也有其他类型的数组可以进行长度计算，因此，构建一个包装类应该是可能的，也是可取的，该包装类可以在其构造函数中接受几种数组（及其长度），并且可以隐式或显式转换为其他包装类和数组类型。不同类型的数组的不同寿命可能是一个问题，但可以通过垃圾收集来解决。