MatG's questions

考虑这个代码（godbolt）：

#include <iostream>

template<typename F> void call_by_val(F funct)
   {
    std::cout << "call_by_val(): ";
    funct();
   }

template<typename F> void call_by_ref(F& funct)
   {
    std::cout << "call_by_ref(): ";
    funct();
   }

template<typename F> void call_by_cref(const F& funct)
   {
    std::cout << "call_by_cref(): ";
    funct();
   }


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


int main()
{
    call_by_val( free_funct );
    call_by_ref( free_funct );
    call_by_cref( free_funct );
}

这三个调用都按预期工作。对于自由函数，我不确定这背后发生了什么，所以我想知道从语义上讲，这三种风格有什么区别。是否有客观理由选择其中一种而不是其他？

考虑 c++98 源代码（godbolt）中的这个（简化的）类层次结构：

class Shape
{
 public:
    virtual class CurvilinearShape as_curvilinear_shape() const =0;
};

class CurvilinearShape : public Shape
{
    // ...
 public:
    virtual CurvilinearShape as_curvilinear_shape() const
       {
        return *this;
       }
};

class PolygonShape : public Shape
{
    // ...
 public:
    virtual CurvilinearShape as_curvilinear_shape() const
       {
        CurvilinearShape curv_shape;
        // Convert...
        return curv_shape;
       }
};

APolygonShape可以轻松转换为CurvilinearShape。 导致这两个不同类别的原因是， aPolygonShape 具有简化的描述，可以由较简单的机器处理，而更先进的机器可以处理更通用的CurvilinearShape 描述符：

void work_curvilinear_shape(CurvilinearShape const&);

在这种情况下，处理基础项序列非常方便，Shape 而不必担心实际使用的描述符，虚拟成员函数as_curvilinear_shape()就是为此引入的：

#include <vector>

int main()
{
    std::vector<Shape*> shapes;
    for(std::vector<Shape*>::const_iterator it=shapes.begin(); it!=shapes.end(); ++it)
       {
        work_curvilinear_shape( (*it)->as_curvilinear_shape() );
       }
}

CurvilinearShape::as_curvilinear_shape()这是可行的，但是存在每次调用时（顺便说一下，大多数时候）都会发生不必要的复制构造的问题。

虽然这似乎是一个相当常见的用例，但我找不到它的名字，你知道吗？我正在寻找一种更好的方法，避免在项目已经是实例的情况下进行不必要的复制CurvilinearShape，也许你们中的一个可以让我走上正确的轨道？

考虑这个旨在收集字符串序列的小类：

class issues_t final
{
 private:
    std::vector<std::string> m_issues;

 public:
    constexpr void operator()(std::string&& txt)
       {
        m_issues.push_back( std::move(txt) );
       }
};

我计划将其用作：

issues_t issues;
do_something(issues);

这有效：

void do_something(issues_t& notify_issue)
{
    notify_issue("something");
}

但我宁愿把它当作：

using fnotify_t = std::function<void(std::string&&)>;
void do_something(fnotify_t const& notify_issue)
{
    notify_issue("something");
}

这可以编译但不起作用：在调试器中push_back()执行但下划线向量未填充（godbolt），所以我在这里缺少什么？

最小可重现示例：

#include <string>
#include <vector>
#include <functional>
#include <print>

class issues_t final
{
 private:
    std::vector<std::string> m_issues;

 public:
    constexpr void operator()(std::string&& txt)
       {
        m_issues.push_back( std::move(txt) );
       }

    [[nodiscard]] constexpr auto begin() const noexcept { return m_issues.cbegin(); }
    [[nodiscard]] constexpr auto end() const noexcept { return m_issues.cend(); }
};

using fnotify_t = std::function<void(std::string&&)>;
void do_first(fnotify_t const& notify_issue)
{
    notify_issue("do_first");
}

void do_second(issues_t& notify_issue)
{
    notify_issue("do_second");
}

int main()
{
    issues_t issues;
    issues("main");
    do_first(issues);
    do_second(issues);

    for( const auto& issue : issues )
       {
        std::print("    {}\n", issue);
       }
}

考虑这样一个类（省略细节）：

template<typename K, typename V>
class my_flat_map
{
    // A lot of member functions taking a const ref to key
    auto find(K const& key) { /*...*/ }
    auto contains(K const& key) { /*...*/ }
    auto insert_or_assign(K const& key, V const& val) { /*...*/ }
    auto insert_if_missing(K const& key, V const& val) { /*...*/ }
    // ...
};

当使用类似字符串的键类型实例化模板时，我希望所有这些成员函数只接受相应的 string_view 而不是对实际键类型的 const 引用。我知道我可以通过对每个可能的字符串类进行部分专业化来获得它：

template<typename V>
class my_flat_map<std::u32string,V>
{
    auto find(std::u32string_view key) { /*...*/ }
    // ...
};

template<typename V>
class my_flat_map<std::u16string,V>
{
    auto find(std::u16string_view key) { /*...*/ }
    // ...
};

template<typename V>
class my_flat_map<std::u8string,V>
{
    auto find(std::u8string_view key) { /*...*/ }
    // ...
};

template<typename V>
class my_flat_map<other::esotic_string,V>
{
    auto find(other::esotic_string_view key) { /*...*/ }
    // ...
};

// ...

所有成员函数的主体完全相同，唯一的变化是签名。是否有一种机制可以在不重复所有代码的情况下表达这一点？