如何为嵌套类编写作用域解析运算符函数头？

Question

嘿，我有一个相当简单的问题，一些快速 google 搜索无法解决，所以我来这里寻求帮助。

我在完成作业时遇到了麻烦，因为我什至无法编写框架代码！

基本上我有一个像这样的头文件：

namespace foo{
    class A {
    public:
        class B {
            B(); 
            int size();
            const int last();
        };
    };
}

而且我想知道如何在实现文件中引用文件外的这些人。

奖金：

namespace foo{

    template<typename T>
    typename
    class A {
    public:
        class B {
            B(); 
            int size();
            const int last();
        };
    };
}

这些函数是怎么称呼的？

有没有我可以遵循的公式，或者它是否更灵活，可以满足您的需求？

感谢您的帮助！

如果有任何改变，我正在使用 visual studios...

Answer 1

要在您的实施 (.cpp) 文件中使用 class，您喜欢这样：

namespace foo{
    A::B::B(){
        // this is your inner class's constructor implementation
    }

    int A::B::size(){
        // implementation for you size()
        int res = last(); // access the method last() of the same object
        return res;
    }

    const int A::B::last(){
        // implementation of last()
        return 42;
    }

}

void main(){
    foo::A a; // construct an object of A
    // can't do anything useful as the methods of A::B are all private
}

Answer 2

鉴于：

namespace foo{
    class A {
    public:
        class B {
            B(); 
            int size();
            const int last();
        };
    };
}

size 或 last 函数定义的完整名称为：

int foo::A::B::size() {...}
const int foo::A::B::last() {...}

鉴于：

namespace foo{

    template<typename T>
    typename
    class A {
    public:
        class B {
            B(); 
            B & operator ++();
            int size();
            const int last();

            template< typename I, typename R>
            R getsomethingfrom( const I & );
        };
    };
}

函数定义为：

template <typename T> int foo::A<T>::B::size() { ... }
template <typename T> const int foo::A<T>::B::last() { ... }

对于这些，获取指向成员函数的指针将是：

auto p = &foo::A<T>::B::size;

构造函数定义为：

template<typename T> foo::A<T>::B::B() {}

做这些事情之一：

foo::A<T>::B nb{}; // note, with nb() it complains

在模板中返回对 B 的引用的运算符函数定义，棘手：

template<typename T>         // standard opening template....
typename foo::A<T>::B &        // the return type...needs a typename 
foo::A<T>::B::operator++()     // the function declaration of operation ++
{ ... return *this; }        // must return *this or equivalent B&

如果你很好奇，如果模板函数在 B 中，比如 getsomethingfrom，那么函数的定义是：

template< typename T>                       // class template
template< typename I, typename R>           // function template
R foo::A<T>::B::getsomethingfrom( const I & ) // returns an R, takes I
{ R r{}; return r }

如何为嵌套类编写作用域解析运算符函数头？

How to write the scope resolution operator function header for nested classes?

c++

templates

data-structures

implementation

scope-resolution