标签: non-member-functions

编译时我收到此错误:

错误C2270:'busco':非成员函数不允许使用修饰符

我想我理解原因,但我不知道如何解决它,如果我拿出const来我得到C2662错误.

这是代码:

    template <class T>
    class ABBImp: public ABB<T> {
    public:
        const T& Recuperar(const T &e) const ;
    private:
        NodoABB<T> * busco(NodoABB<T> * arbol,T &e) const;
    protected:
        NodoABB<T>* arbol;
    };

    template <class T>
//If I take this const out I get the other error I talked about
    NodoABB<T>* busco(NodoABB<T> * arbol,T &e)const{
        if(a!=NULL){
            if(arbol->dato==e)
                return arbol;
            else if (arbol->dato<e)
                return busco(arbol->der,e);
            else
                return busco(arbol->izq,e);
        }else{
            return NULL;
        }
    }
    template <class T>
    const T& ABBImp<T>::Recuperar(const T …

在2017年的cppcon视频中,我遇到了Klaus Iglberger的一个名为" Free Your Functions! " 的演讲.在这次演讲中,演讲者谈到了如何切换到自由函数可以简化测试私有方法的过程(参见19:00).这个想法是你将私有方法拉出类(你使它成为一个自由函数),它变得可测试.

起初,我觉得这个想法很有意思,但是我想的越多,我就越不了解这实际上应该如何工作.例如,假设我有以下(虚拟)类:

class SomeClass
{
public:
    SomeClass();
    ~SomeClass();

    void someTask();

private:

    void someComplexTask();
    void someOtherComplexTask();

};

void SomeClass::someTask()
{
    someComplexTask();
    someOtherComplexTask();
}

// private tasks implementations...

然后someComplexTask()和someOtherComplexTask()是私有方法.这意味着它们是实现细节,即它们只能在内部SomeClass(或朋友)调用.在我看来,如果你让它们成为自由函数,是的它们变得可测试,但它们不再是私有的,也不仅仅是特定的实现细节SomeClass.实际上,它们可以从代码中的任何地方调用......

所以我的问题是:为什么Iglberger先生的观点有效？

在 C++17 中，是否有一种简单的方法来 std::visit 带有重载自由函数的变体，或者我必须使用带有重载调用运算符的对象？

换句话说，是否可以添加一些简单的东西来使以下//ERROR!行编译为与该//OK!行在功能上相同？

#include<variant>
#include<iostream>
#include<list>

#include <boost/hana/functional/overload.hpp>
using boost::hana::overload;

struct A {};
struct B {};

void foo(A) { std::cout << "Got an A!\n"; }
void foo(B) { std::cout << "Got a  B!\n"; }

using AorB = std::variant<A,B>;

constexpr auto foo_obj = overload(
    [](A){std::cout << "Got an A!\n";},
    [](B){std::cout << "Got a  B!\n";});

int main() {

  std::list<AorB> list{A(), B(), A(), A(), B()};

  for (auto& each : list) std::visit(foo, each);      // ERROR!
  for (auto& …

在C++中，我需要定义一些内联通用函数。但是，当我在头文件中编写原型并在 .cpp 文件中编写实现时，遇到“LNK2001 无法解析的外部符号”错误。

我要删除.cpp文件并在头文件中实现该功能吗？

我正在尝试定义一些可供其他类使用的共享非成员数学函数。

头文件：

inline void foo()
{
    //some code
}

.cpp 文件

//nothing

（读完这篇文章及其接受的答案后，这个问题突然出现在我的脑海中。）

假设一个Foo您无法修改的类，它有一个publicmember bar，但没有它的 getter 。

您可能想要编写一个函数来在传递 a 时获取该成员Foo，以便您可以在更高阶的函数中使用它，例如std::transform和 类似的函数。

换句话说，给定这样一个类

struct Foo {
    int bar{};
    ~Foo() { bar = -1; } // on most compilers this helps "verifying" that the object is dead
};

我想要一些getFoo与具有相同语义的类型，其中是 类型的任何对象，可以是纯右值、x值或左值。getBar(expr-of-type-Foo)expr-of-type-Foo.barexpr-of-type-FooFoo

你怎么写呢？

我最初想到的是：

        constexpr auto getBar = overload(
            [](auto& foo) -> decltype(auto) { return (foo.bar); },
            [](auto const& foo) -> decltype(auto) { return …