She*_*ien 9 c++ templates metaprogramming compile-time-constant
存在库源可用的情况,并且它通常必须支持变量参数,但实际上这些参数通常是常量.
然后可以通过对常量参数的特殊处理来优化事物(例如,使用静态数组而不是堆分配),但为此必须首先确定某些事物是否是常量(或者可能定义一些宏,但它不太方便).
所以这是一个有效的实现.
更新:也在这里:http://codepad.org/ngP7Kt1V
更新:这是一个更符合预期用途的更新.if(N==0)如果N不是0 ,编译器将不会为分支生成任何代码.如果需要,我们可以切换到完全不同的数据结构.当然它不完美,但这就是我发布这个问题的原因.
#include <stdio.h>
struct chkconst {
struct Temp { Temp( int x ) {} };
static char chk2( void* ) { return 0; }
static int chk2( Temp ) { return 0; }
};
#define is_const_0(X) (sizeof(chkconst::chk2(X))<sizeof(int))
#define is_const_0i(X) (sizeof(chkconst::chk2(X))>sizeof(char))
#define is_const(X) is_const_0( (X)^((X)&0x7FFFFFFF) )
#define const_bit(X1,bit) (is_const_0i((X1)&(1<<bit))<<bit)
#define const_nibl(X1,bit) const_bit(X1,bit) | const_bit(X1,(bit+1)) | const_bit(X1,(bit+2)) | const_bit(X1,(bit+3))
#define const_byte(X1,bit) const_nibl(X1,bit) | const_nibl(X1,(bit+4))
#define const_word(X1,bit) const_byte(X1,bit) | const_byte(X1,(bit+8))
#define const_uint(X1) const_word(X1,0) | const_word(X1,16)
#define const_switch_word( X1, X2 ) (is_const(X1) ? const_word(X1,0) : X2)
#define const_switch_uint( X1, X2 ) (is_const(X1) ? const_uint(X1) : X2)
const int X1 = 222;
const int X2 = printf( "" ) + 333;
char Y1[ const_switch_word(X1,256) ];
char Y2[ const_switch_word(X2,256) ];
template< int N >
void test( int N1 ) {
char _buf[N>0?N:1];
char* buf = _buf;
if( N==0 ) {
buf = new char[N1];
}
printf( "%08X %3i %3i\n", buf, N, N1 );
}
#define testwrap(N) test< const_switch_word(N,0) >( N )
int main( void ) {
printf( "%i %i %i\n", X1, is_const(X1), sizeof(Y1) );
printf( "%i %i %i\n", X2, is_const(X2), sizeof(Y2) );
testwrap( X1 );
testwrap( X2 );
}
如果您可以传入模板参数，那么它一定是 constexpr（编译时表达式的标准术语）。如果它不是通过模板参数传递的，那么它不是 constexpr。这是没有办法解决的。
更容易的是使用 alloca 手动滚动堆栈分配的可变长度数组类。这将保证数组的堆栈分配，无论它们是否是静态的。此外，您还可以获得与 vector/boost::array 相同的迭代功能。
#define MAKE_VLA(type, identifier, size) VLA< (type) > identifier ( alloca( (size) * sizeof ( type ) ), (size) );
template<typename T> class VLA {
int count;
T* memory;
VLA(const VLA& other);
public:
// Types
typedef T* pointer;
typedef T& reference;
typedef const T* const_pointer;
typedef const T& const_reference;
typedef T value_type;
typedef std::size_t size_type;
class iterator {
mutable T* ptr;
iterator(T* newptr)
: ptr(newptr) {}
public:
iterator(const iterator& ref)
: ptr(ref.ptr) {}
operator pointer() { return ptr; }
operator const pointer() const { return ptr; }
reference operator*() { return *ptr; }
const reference operator*() const { return *ptr; }
pointer operator->() { return ptr; }
const pointer operator->() const { return ptr; }
iterator& operator=(const iterator& other) const {
ptr = iterator.ptr;
}
bool operator==(const iterator& other) {
return ptr == other.ptr;
}
bool operator!=(const iterator& other) {
return ptr != other.ptr;
}
iterator& operator++() const {
ptr++;
return *this;
}
iterator operator++(int) const {
iterator retval(ptr);
ptr++;
return retval;
}
iterator& operator--() const {
ptr--;
return *this;
}
iterator operator--(int) const {
iterator retval(ptr);
ptr--;
return retval;
}
iterator operator+(int x) const {
return iterator(&ptr[x]);
}
iterator operator-(int x) const {
return iterator(&ptr[-x]);
}
};
typedef const iterator const_iterator;
class reverse_iterator {
mutable T* ptr;
reverse_iterator(T* newptr)
: ptr(newptr) {}
public:
reverse_iterator(const reverse_iterator& ref)
: ptr(ref.ptr) {}
operator pointer() { return ptr; }
operator const pointer() const { return ptr; }
reference operator*() { return *ptr; }
const reference operator*() const { return *ptr; }
pointer operator->() { return ptr; }
const pointer operator->() const { return ptr; }
reverse_iterator& operator=(const reverse_iterator& other) const {
ptr = reverse_iterator.ptr;
}
bool operator==(const reverse_iterator& other) {
return ptr == other.ptr;
}
bool operator!=(const reverse_iterator& other) {
return ptr != other.ptr;
}
reverse_iterator& operator++() const {
ptr--;
return *this;
}
reverse_iterator operator++(int) const {
reverse_iterator retval(ptr);
ptr--;
return retval;
}
reverse_iterator& operator--() const {
ptr++;
return *this;
}
reverse_iterator operator--(int) const {
reverse_iterator retval(ptr);
ptr++;
return retval;
}
reverse_iterator operator+(int x) const {
return reverse_iterator(&ptr[-x]);
}
reverse_iterator operator-(int x) const {
return reverse_iterator(&ptr[x]);
}
};
typedef const reverse_iterator const_reverse_iterator;
typedef unsigned int difference_type;
// Functions
~VLA() {
for(int i = 0; i < count; i++)
memory[i].~T();
}
VLA(void* stackmemory, int size)
: memory((T*)stackmemory), count(size) {
for(int i = 0; i < count; i++)
new (&memory[i]) T();
}
reference at(size_type pos) {
return (reference)memory[pos];
}
const_reference at(size_type pos) {
return (const reference)memory[pos];
}
reference back() {
return (reference)memory[count - 1];
}
const_reference back() const {
return (const reference)memory[count - 1];
}
iterator begin() {
return iterator(memory);
}
const_iterator begin() const {
return iterator(memory);
}
const_iterator cbegin() const {
return begin();
}
const_iterator cend() const {
return end();
}
const_reverse_iterator crbegin() const {
return rbegin();
}
const_reverse_iterator crend() const {
return rend();
}
pointer data() {
return memory;
}
const_pointer data() const {
return memory;
}
iterator end() {
return iterator(&memory[count]);
}
const_iterator end() const {
return iterator(&memory[count]);
}
reference front() {
return memory[0];
}
const_reference front() const {
return memory[0];
}
reverse_iterator rbegin() {
return reverse_iterator(&memory[count - 1]);
}
const_reverse_iterator rbegin() const {
return const_reverse_iterator(&memory[count - 1]);
}
reverse_iterator rend() {
return reverse_iterator(memory[-1]);
}
const_reverse_iterator rend() const {
return reverse_iterator(memory[-1]);
}
size_type size() {
return count;
}
reference operator[](int index) {
return memory[index];
}
const reference operator[](int index) const {
return memory[index];
}
};
请注意，我还没有实际测试过这段代码，但它比在你的 OP 中维护这个庞然大物更容易获取、使用和维护。