1

我写了一个宏，可以在类定义周围添加，这将有效地完成它（防止子类化）。这种终结方法是一种相当常见的技术，在C++ FAQ中有说明：

#define FINALIZE(NAME,...) \
    NAME##Finalizer {\
        private:\
            friend class NAME;\
            inline NAME##Finalizer(void) {}\
    };\
    class NAME : public virtual NAME##Finalizer, __VA_ARGS__

例如：

class FINALIZE(Fred) {};
//The above line evaluates to:
//  class FredFinalizer {
//      private:
//          friend class Fred;
//          inline FredFinalizer(void) {}
//  };
//  class Fred : public virtual FredFinalizer, {};

class George {};
class FINALIZE(Fred2, public George) {};
//The above line evaluates to:
//  class Fred2Finalizer {
//      private:
//          friend class Fred2;
//          inline Fred2Finalizer(void) {}
//  };
//  class Fred2 : public virtual Fred2Finalizer, public George {};

class Velma : public Fred { Velma(void) {} /*Note compile error*/ };
class Velma2 : public Fred2 { Velma2(void) {} /*Note compile error*/ };

这非常有效。问题是我现在想要一种“禁用”宏的方法。那是：

class FINALIZE(Fred) {};
//The above line evaluates to:
//  class Fred {};

class George {};
class FINALIZE(Fred2, public George) {};
//The above line evaluates to:
//  class Fred2 : public George {};

问题是class Fred2 : public George {};与没有继承（class Fred {};）的情况发生冲突：在第一种情况下，必须始终有一个冒号，在第二种情况下，必须没有。请注意，启用宏时这不是问题，因为该类始终至少继承自NAME##Finalizer 类。

我怎样才能写一个宏来做到这一点？

4

1 回答 1

1

我建议制作两个宏，一个用于准备终结器，一个用于使用：

#define PREP_FINALIZE(NAME) \
    class NAME##Finalizer {\
        private:\
            friend class NAME;\
            inline NAME##Finalizer() {}\
    }

#define FINALIZE(NAME) virtual NAME##Finalizer

所以在你的例子中：

PREP_FINALIZE(Fred);
class Fred : FINALIZE(Fred) {};

class George {};
PREP_FINALIZE(Fred2);
class Fred2 : FINALIZE(Fred2), public George {};

但是更重要的是，您忘记了将复制构造函数设为私有。没有它，你的方式很容易作弊：

// cheating :D
class Velma : public Fred, FINALIZE(Fred) { 
   Velma() : FredFinalizer(*(FredFinalizer*)0) {} /*Who said this is compiler error */ 
};

将终结器的复制构造函数设为私有。或者使用我对非常相似的问题的回答。

对于 C++11，只需使用 final ;)

于 2012-09-15T20:54:13.200 回答