All perguntas(coding)

A versão variádica sobrecarregada de uma função deve ter a menor prioridade, quando o compilador escolhe uma especialização de modelo. No entanto, esse não é o caso quando um argumento de função precisa ser convertido para uma classe base antes de corresponder a um argumento de modelo. Veja o exemplo abaixo.

class A {};
class B : public A {};
template<class... Args>
void foo(Args&&... argsPack) {
    std::cout << "variadic function called" << std::endl;
}
void foo(A&) {
    std::cout << "non-variadic function called" << std::endl;
}


int main() {
    foo("Hello");
    B b;
    foo(b);
}

A saída deste programa resulta em

variadic function called
variadic function called

Se eu quisesse que a função não-variádica fosse chamada, eu teria que deletar a função sobrecarregada variádica inteiramente. Ou alternativamente eu teria que escrever uma terceira função sobrecarregada que aceitasse instâncias da classe B diretamente:

void foo(B&) {
    std::cout << "non-variadic function called" << std::endl;
}

No entanto, quero evitar ambas as soluções, porque elas não são elegantes e propensas a erros para meu projeto. Então, há uma terceira solução para isso?

Não é possível recuperar argumentos do construtor em uma tupla.

Estou tentando extrair os tipos de parâmetros do construtor de uma dada classe como um std::tuple. Por exemplo, se eu tiver uma classe como esta:

struct MyClass {
    MyClass(int, double, std::string) {}
};

Quero obter um tipo como std::tuple<int, double, std::string>correspondente aos parâmetros do construtor.

Estou ciente de que no Boost.DI, isso parece ser possível, já que eles conseguem resolver dependências do construtor automaticamente. No entanto, não consegui encontrar uma explicação clara de como eles extraem os tipos de parâmetros do construtor.

Para funções regulares, sei como usar std::tuplemodelos, conforme mostrado abaixo:

template <typename Func>
struct function_traits;

// Specialization for functions
template <typename Ret, typename... Args>
struct function_traits<Ret(Args...)> {
    using args_tuple = std::tuple<Args...>;
};

No entanto, não tenho certeza de como adaptar essa abordagem para construtores.

Restrições:

• Prefiro soluções compatíveis com C++14 ou C++17, mas estou aberto a ver abordagens usando C++20 ou mais recente.
• Não sou contra o uso do Boost ou de outras bibliotecas, se necessário.

Alguém poderia me orientar sobre como conseguir isso? Talvez um exemplo mínimo ou uma explicação de como o Boost.DI faz isso?

Caso haja vários construtores, o boost di diz que escolhe o construtor mais longo. Como ele faz isso também?

Exemplo de como o boost di funciona (da documentação oficial). ref : boost di exemple

// $CXX -std=c++14 basic_create_objects_tree.cpp
#include <boost/di.hpp>

namespace di = boost::di;

struct renderer {
  int device;
};

class view {
 public:
  view(std::string /*title*/, const renderer&) {}
};

class model {};

class controller {
 public:
  controller(model&, view&) {}
};

class user {};

class app {
 public:
  app(controller&, user&) {}
};

int main() {
  /**
   * renderer renderer_;
   * view view_{"", renderer_};
   * model model_;
   * controller controller_{model_, view_};
   * user user_;
   * app app_{controller_, user_};
   */

  auto injector = di::make_injector();
  injector.create<app>();
}

Acho que tenho uma pista usando este arquivo, mas ainda não consigo entender completamente o sistema e como posso implementá-lo. boost/di/type_traits/ctor_traits.hpp

No Django 5.1 {% querystring %} foi adicionado. Existe alguma maneira de usá-lo com o formulário GET?

Por exemplo, digamos que temos um modelo com:

<span>Paginate by:</span>
<a href="{% querystring paginate_by=50 %}">50</a>

{# ... #}

<form method="GET">
    <input name="query" value="{{ request.GET.query }}">

    <button type="submit">Search</button>
</form>

Supondo que estamos atualmente em localhost:8000/?paginate_by=50, como alterar formpara que clicar Searchnão exclua paginate_byo parâmetro de consulta - então o que eu quero é por exemplo localhost:8000/?paginate_by=50&query=abce não localhost:8000/?query=abc?

Antes da versão 5.1, eu lidava com isso fornecendo um formulário com campos ocultos com base em parâmetros GET, mas espero que agora seja possível uma solução mais elegante.

Quero alterar o tamanho do buffer para E/S de arquivo durante a leitura/gravação em arquivos do PHP, mas a única maneira de fazer isso é stream_set_write_buffer()sempre retornando -1. Não consegui encontrar nenhuma descrição de erro com error_reporting(E_ALL);ou algo assim.

Tenho um exemplo ao vivo que reproduz o problema: https://onlinephp.io/c/5955f

Estou pedindo ajuda, por que ele falha? Como fazer funcionar e o que estou esquecendo? Nenhum médico me ajudou até agora.

Tentando fazer minha barra de navegação ser uma série de círculos onde se você passar o mouse sobre eles, ela exibe o texto que os acompanha. Aqui está o que eu tenho até agora:

document.querySelectorAll('.color-circle').forEach((circle, index) => {
  circle.addEventListener('click', () => {
    alert(`Navigate to: ${circle.querySelector('.orbit-text').innerText}`);
  });
});

.color-circle {
  position: relative;
  border-radius: 50%;
  cursor: pointer;
  transition: transform 0.3s ease;
}

.color-circle:hover {
  transform: scale(1.2);
}

.orbit {
  position: absolute;
  width: 100%;
  height: 100%;
  opacity: 0;
  transition: opacity 0.3s ease;
}

.color-circle:hover .orbit {
  opacity: 1;
  animation: orbit 2s linear infinite;
}

.orbit-text {
  position: absolute;
  left: 50%;
  top: 50%;
  transform-origin: center;
  transform: translate(-50%, -50%) rotateY(0deg);
  color: white;
  font-size: 8px;
  font-weight: bold;
  text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
  animation: orbit3D 4s linear infinite;
}

@keyframes orbit3D {
  from {
    transform: translate(-50%, -50%) rotateY(0deg) translateZ(15px);
  }
  to {
    transform: translate(-50%, -50%) rotateY(360deg) translateZ(15px);
  }
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.8.3/angular.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.3.1/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/18.3.1/umd/react-dom.production.min.js"></script>

<div class="top-bar visible">
  <div class="circle-container">
    <div class="color-circle" style="background-color: rgb(227, 197, 103); width: 40px; height: 40px;">
      <div class="orbit">
        <span class="orbit-text">HOME</span>
      </div>
    </div>
    <div class="color-circle" style="background-color: rgb(200, 150, 62); width: 30px; height: 30px;">
      <div class="orbit">
        <span class="orbit-text">DEV & DESIGN</span>
      </div>
    </div>
    <div class="color-circle" style="background-color: rgb(87, 61, 28); width: 25px; height: 25px;">
      <div class="orbit">
        <span class="orbit-text">ACTING</span>
      </div>
    </div>
    <div class="color-circle" style="background-color: rgb(217, 174, 97); width: 20px; height: 20px;">
      <div class="orbit">
        <span class="orbit-text">FILMMAKING</span>
      </div>
    </div>
    <div class="color-circle" style="background-color: rgb(209, 70, 47); width: 15px; height: 15px;">
      <div class="orbit">
        <span class="orbit-text">GALLERY</span>
      </div>
    </div>
  </div>
</div>

O espaçamento e outras formatações não foram feitos, mas estou batendo na parede com o texto distorcido, como se estivesse curvado quando virado para longe, e mais plano quando mais perto, como se estivesse realmente gravado na esfera giratória.

Obrigado!

Como posso armazenar uma exibição composta de intervalos C++20 como um membro de classe?

Tentei com o seguinte código que funciona em geral, mas se eu colocar a estrutura em um cabeçalho, o GCC me avisa que splitter::viewtem ligação interna. (-Werror=subobject-linkage)

Acho que o GCC está certo neste caso, mas não sei como configurá-lo para vinculação externa.

Mas acho que tenho um problema mais fundamental aqui, que é que não consigo nomear o tipo de visualização de intervalo. Em teoria, eu poderia digitar isso, mas é um saco se eu adicionar outro filtro à visualização.

#include <ranges>
#include <string_view>

#include <fmt/core.h>

struct splitter {
    static constexpr auto split = [](std::string_view command) {
          return command
              | std::views::split(' ')
              | std::views::filter([](auto range) { return !std::ranges::empty(range); })
              | std::views::transform([](auto range) { return std::string_view(range); });
    };

    using ViewType = decltype(split(std::declval<std::string_view>()));

    ViewType view;

    splitter(std::string_view str)
        : view(split(str))
    {
    }
};

int main() {

    std::string_view str = " test foo  bar ";

    splitter sptl(str);
    for (auto s : sptl) {
        fmt::print("token {} with size {}", s, s.size());
    }
}

Aqui está um link do godbolt para a versão do cabeçalho: https://godbolt.org/z/avMhqofcf

Em R, tenho o seguinte dataframe com a coluna "overlap" listando linhas que têm valores sobrepostos em alguma outra coluna.

df <- data.frame(overlap = c("1,2,3", "1,2,3", "1,2,3,4", "3,4", 
                              "5,6", "5,6,7", "6,7", 
                              "8,9", "8,9,10", "9,10", 
                              "11,12,13", "11,12,13", 
                              "11,12,13,14", "13,14", 
                              "15,16", "15,16,17", "16,17", 
                              "18,19", "18,19,20", "19,20"))

df
         overlap
  1        1,2,3
  2        1,2,3
  3      1,2,3,4
  4          3,4
  5          5,6
  6        5,6,7
  7          6,7
  8          8,9
  9       8,9,10
  10        9,10
  11    11,12,13
  12    11,12,13
  13 11,12,13,14
  14       13,14
  15       15,16
  16    15,16,17
  17       16,17
  18       18,19
  19    18,19,20
  20       19,20

Gostaria de identificar linhas com valores comuns, mesmo que esses valores não estejam em todas as linhas, e então manter apenas 1 das linhas. Por exemplo, as linhas 1-4 contêm o conjunto combinado 1,2,3,4 e eu gostaria de manter apenas uma dessas linhas. Se mantivermos a primeira linha, o df resultante seria:

  1        1,2,3
  5          5,6
  8          8,9
  11    11,12,13
  15       15,16
  18       18,19

Pesquisei muitas outras soluções aqui e nenhuma inclui comprimentos de linhas desiguais, o que é vital, pois os dados completos podem ter linhas com dezenas de valores.

Usando a indexação de pacotes do C++26 , você pode criar uma tupla simples de tipos como esta:

template <typename... Ts>
struct type_tuple {
    template <unsigned Index>
    using get = Ts...[Index];
};

using T = type_tuple<int, float, double>::get<1>; // float

Como isso pode ser replicado em versões anteriores do C++?

Quero usar a std::filesystem::remove()função para remover um arquivo, e dar um erro se o arquivo não existir. Algo assim:

std::error_code errorCode;
if (!std::filesystem::remove("<some file path>", errorCode))
{
    std::cout << "Could not delete file because " << errorCode.message();
}

Entretanto, se o arquivo não existir, isso gerará a mensagem Could not delete file because unknown error.

Minha pergunta é: por que isso não me diz que o arquivo não existe?

Eu interpreto a documentação em cppreference para dizer que

• A error_codeversão não da removefunção retorna falsese o arquivo não existe e gera uma exceção em outros erros.
• A error_codeversão retorna false em qualquer erro e armazena o motivo no error_code. Ela nunca lança uma exceção.

Dado que o código de erro apenas diz "erro desconhecido" quando um arquivo não existe, parece que esta versão dá menos informações do que a não- error_code1? Ou talvez eu esteja entendendo algo errado?

Estou no Windows 11, usando o Visual Studio 2022 versão 17.11.2.

Estou testando modelos e conceitos em C++. Escrevi o seguinte código.

#include <iostream>
#include <string>

template <typename T>
concept Printable = requires(T a) {
    { to_string(a) } -> std::same_as<std::string>;
};

typedef struct myStruct {
    std::string name;
} myStruct_t;

// Implement to_string for myStruct_t
std::string to_string(myStruct_t arg) {
    return arg.name;
}

// Implement to_string for int
std::string to_string(int arg) {
    return "it's an integer";
}

// a function that requires Printable
template <typename T>
requires Printable<T>
void show(T arg) {
    std::cout << to_string(arg) << std::endl;
}

int main(){
    myStruct_t a = {"hello"};
    show(a); // passes compilation
    show(5); // error: no matching function for call to ‘show(int)’
             // note: the required expression ‘to_string(a)’ is invalid
    return 0;
}

O compilador reconhece com sucesso que myStruct_tsatisfaz Printableo conceito, mas falha em corresponder intcom Printableo conceito. Gostaria de saber como posso informar ao compilador que o inttambém é Printable.

Pesquisei na internet e descobri que o compilador encontra a to_stringfunção necessária para Printableo conceito por meio de pesquisa dependente de argumento (ADL). Como intnão está sujeito a ADL, o compilador falha em reconhecer a função ao tentar fazer check- intin Printable. Gostaria de saber se não há como fazer int Printable.