MatG's questions

Considere este código ( 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 );
}

Todas essas três chamadas funcionam como esperado. No caso de uma função livre, não tenho certeza do que está acontecendo por baixo do tapete, então estou pensando qual é a diferença entre esses três estilos, semanticamente falando. Existe uma razão objetiva para preferir um em vez dos outros?

Considere esta hierarquia de classes (simplificada) em uma fonte 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;
       }
};

A PolygonShapepode ser facilmente convertido em um arquivo CurvilinearShape. A razão que levou a essas duas classes distintas é que a possui uma descrição simplificada que pode ser processada por máquinas mais simples, enquanto as mais avançadas podem processar o descritor PolygonShape mais genérico :CurvilinearShape

void work_curvilinear_shape(CurvilinearShape const&);

Neste caso é muito útil processar uma sequência de Shape itens base sem se preocupar com o descritor real utilizado, a função de membro virtual as_curvilinear_shape()foi introduzida apenas para isso:

#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() );
       }
}

Isso funciona, mas tem o problema da construção desnecessária de cópias que ocorre cada vez que CurvilinearShape::as_curvilinear_shape()é chamado (aliás, na maioria das vezes).

Embora este pareça um caso de uso bastante comum, não consigo encontrar um nome para ele, você conhece? Estou procurando uma abordagem melhor que evite cópias desnecessárias caso o item já seja uma CurvilinearShapeinstância, talvez um de vocês possa me colocar no caminho certo?

Considere esta pequena aula destinada a coletar uma sequência de strings:

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) );
       }
};

Eu pretendo usar isso como:

issues_t issues;
do_something(issues);

Isso funciona:

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

Mas prefiro consumir isso como:

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

Isso compila, mas não funciona: no depurador, o push_back()é executado, mas o vetor sublinhado não é preenchido ( godbolt ), então o que estou perdendo aqui?

exemplo reproduzível mínimo:

#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);
       }
}

Considere uma classe como esta (omitindo detalhes):

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) { /*...*/ }
    // ...
};

Ao instanciar o modelo com um tipo de chave semelhante a uma string, gostaria que todas as funções-membro aceitassem apenas o string_view correspondente em vez de uma referência const ao tipo de chave real. Eu sei que posso obter isso com uma especialização parcial para cada classe de string possível:

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) { /*...*/ }
    // ...
};

// ...

Os órgãos de todas as funções membro são exatamente os mesmos, a única alteração é a assinatura. Existe um mecanismo para expressar isso sem repetir todo o código?