0 
    namespace first {
    namespace second {
        class Third {
            static void foo() {
                std::cout << "foo\n";
            }
        };
    }
    }

    void bar() {
        std::cout << "bar\n";
    }

    #define first::second::Third::foo bar//this doesn't work

那么，将嵌套函数映射到另一个函数的正确方法是什么？

更新：

更类似的情况是：

    struct ReleaseVersion {
        static void foo() {
            std::cout << "release version\n";
        }
    };

    struct DebugVersion {
        static void foo() {
            std::cout << "debug version\n";
        }
    };

    #ifdef _DEBUG 
    #define ReleaseVersion::foo DebugVersion::foo
    #else
    #define DebugVersion::foo ReleaseVersion::foo
    #endif

我要做的就像malloc和_malloc_dbg一样，当#define _CRTDBG_MAP_ALLOC时，在debug模式下malloc会映射到_malloc_dbg，而在release模式下，_malloc_dbg会映射到malloc

再次更新

更类似的情况是：

    namespace first {
    namespace second {
    struct ReleaseVersion {
        static void foo() {
            std::cout << "release version\n";
        }
    };
    
    struct DebugVersion {
        static void foo(const char* file, long line) {
            std::cout << "debug version\n";
        }
    };
    }
    }
    #ifdef _DEBUG 
    #define ReleaseVersion::foo() DebugVersion::foo(__FILE__, __LINE__)
    #else
    #define DebugVersion::foo(file, line) ReleaseVersion::foo()
    #endif

所以，这两个版本的函数可能有不同的参数，我不能只调用一个。我知道我可以做到这一点

    #ifdef _DEBUG 
    #define Foo() first::second::DebugVersion::foo(__FILE__, __LINE__)
    #else
    #define Foo() first::second::ReleaseVersion::foo()

但是这样一来，我必须一直使用 Foo()，即使在最终发布模式下，它仍然是一个宏。我想知道是否有更灵活的方法可以做到这一点。

一种解决方案

    #ifdef _DEBUG 
    #define foo() foo(__FILE__, __LINE__)
    #define ReleaseVersion DebugVersion
    #else
    #define foo(file, line) foo()
    #define DebugVersion ReleaseVersion
    #endif
    
    
    int main() {
        first::second::DebugVersion::foo(__FILE__, __LINE__);
        first::second::ReleaseVersion::foo();
        return 0;
    }

当其他命名空间中有另一个 foo() 或 RealeaseVersion/DebugVersion 时可能很危险，但如果你能确保不会有，我认为这可能是一个可以接受的解决方案。

4

3 回答 3

2

你#define的方法是错误的：

#define bar first::second::Third::foo

意味着bar它将被替换first::second::Third::foo，我相信这就是你想要的。

这是相反的typedef，事情是相反的。

我不确定你想要什么，但这有效：

namespace first {
namespace second {
    class Third {
        public: static void foo() {
            std::cout << "foo\n";
        }
    };
}
}

#define bar first::second::Third::foo

int main()
{
  bar();
}
于 2013-02-20T11:09:44.050 回答
1

malloc/工作方式free是通过宏替换：

#ifdef WANT_DEBUG_MALLOC
#define malloc(x) debug_malloc(x, __FILE__, __LINE__)
#define free(x)   debug_free(x, __FILE__, __LINE__)
#endif

当预处理器看到struct foo *p = malloc(sizeof(struct foo) * 10);它将替换为struct foo *p = debug_malloc(sizeof(struct foo) * 10, "myfile.c", 103);

但是，如上所述，在进行宏替换时，您不能真正使用命名空间。您必须单独替换命名空间，或者单独替换函数名。当然，可以有两个宏，一个替换命名空间，一个替换函数名。但它很快就会变得非常混乱，所以最好避免，我会说。

于 2013-02-20T12:18:23.677 回答
0

我宁愿使用内联函数

#ifdef _DEBUG 
static inline void DoFoo() { DebugVersion::foo(); }
#else
static inline void DoFoo() { ReleaseVersion::foo(); }
#endif
于 2013-02-20T12:31:32.573 回答