Início / user-11185987

Roger World's questions

Martin Hope
Roger World
Asked: 2025-04-09 14:52:51 +0800 CST
  • 9

Estou explorando o novo recurso de dedução introduzido no C++23 e tentando entender como combiná-lo efetivamente com o Curiously Recurring Template Pattern (CRTP) para implementar comportamento polimórfico sem depender de funções virtuais tradicionais.

Meu objetivo é gerenciar uma coleção de objetos derivados (por exemplo, formas, processadores, etc.) de forma apagada ou semipolimórfica e ainda obter os benefícios do polimorfismo estático e possivelmente reduzir a indireção e a alocação dinâmica.

#include <vector>
#include <iostream>

template <typename Derived>
struct Base {
    void process(this Derived& self) {
        self.impl(); // supposed to call derived's impl()
    }
};

struct DerivedA : Base<DerivedA> {
    void impl() {
        std::cout << "DerivedA::impl\n";
    }
};

struct DerivedB : Base<DerivedB> {
    void impl() {
        std::cout << "DerivedB::impl\n";
    }
};

int main() {
    std::vector</* ??? */> collection;

    collection.push_back(DerivedA{});
    collection.push_back(DerivedB{});

    for (auto& obj : collection) {
        obj.process(); // call the correct impl() for each type
    }
}

Sei que essa std::varianté uma maneira de lidar com isso, mas estou procurando soluções alternativas de alto desempenho. Idealmente, gostaria de evitar a sobrecarga de alocações dinâmicas e funções virtuais e usar recursos modernos do C++23, como deduzir isso com CRTP, para obter os benefícios do polimorfismo estático.

c++
Martin Hope
Roger World
Asked: 2024-10-19 01:32:18 +0800 CST
  • 6

Conforme mostrado na cppreference.

A autopalavra-chave pode ser usada para se livrar do modelo com concept.

// Constrained C++20 function template:
template<Hashable T>
void f(T) {}
//
// Alternative ways to apply the same constraint:
// template<typename T>
//     requires Hashable<T>
// void f(T) {}
//
// template<typename T>
// void f(T) requires Hashable<T> {}
//
void f(Hashable auto /* parameter-name */) {}

Minha pergunta é como usar a mesma técnica autoquando tenho dois parâmetros de modelo.

template<typename T1, typename T2> concept MyConcept<T1, T2> = ....

template<typename T1, typename T2> 
void func(MyConcept<T1, T2> c) { ... }
// Why cannot use :
void func(MyConcept auto c) { ... }
c++
Martin Hope
Roger World
Asked: 2024-09-24 19:29:43 +0800 CST
  • 6

Tenho uma durationstring como eg "13:00:00"e uma time_pointanalisada para um utc_time a partir de uma string de hora UTC usando std::chrono::parsea função.

Agora, dada essa duração e um fuso horário, por exemplo "America/New_York". Como comparar minha time_pointduração com a de hoje como ponto de tempo usando UTC como fuso horário comum. A documentação tz do cppreference chrono ainda não foi concluída.

c++