alfC's questions

Se eu tiver um intervalo, posso imprimi-lo com a biblioteca fmt, desta forma: https://fmt.dev/8.1.0/api.html#ranges-api

#include <fmt/ranges.h>

std::vector<int> t = {1, 2, 3};
// Prints "[1, 2, 3]"
fmt::print("{}", t);

E se eu quiser controlar o separador:

// Prints "1| 2| 3"
fmt::print("{}", fmt::join(t, "| "));

O que acontece se eu tiver contêineres aninhados, por exemplo std::vector<std::vector<int>>, como posso controlar o separador aninhado?

std::vector<std::vector<int>> v = ...
fmt::print("{}", fmt::join(t, "| "));

isso será impresso [1, 2, 3]| [4, 5, 6]| [7, 8, 9].

Observe que só posso controlar o formato de nível superior.

Para contextualizar, estou tentando controlar a formatação de matrizes multidimensionais: https://godbolt.org/z/M9cTEox7c

Tenho um código legado que se lê assim:

bool has_attribute(int kvidx) const {
    void* v = nullptr;
    int flag = 0;
    MPI_Comm_get_attr(impl_, kvidx, &v, &flag);
    return flag != 0;
}

O terceiro argumento de MPI_Comm_get_attr pega umvoid** .

CORREÇÃO: … pega void*, mas é void**semanticamente de acordo com a documentação da função. Esta é a verdadeira origem do aviso.

Este código agora está emitindo um aviso sonoro bugprone-multi-level-implicit-pointer-conversion.

https://releases.llvm.org/18.1.0/tools/clang/tools/extra/docs/clang-tidy/checks/bugprone/multi-level-implicit-pointer-conversion.html

Clang-tidy recomenda: "conversão de ponteiro multinível de 'char **' para 'void *', use conversão explícita"

Como aplico esse "elenco explícito"?

Eu tentei, MPI_Comm_get_attr(impl_, kvidx, static_cast<void**>(&v), &flag);mas o clang continua reclamando.

Para esclarecer, o código está correto AFAIK, estou tentando seguir a recomendação do clang-tidy (sem suprimir o aviso)

Eu tenho um código usando SFINAE "clássico".

template<class M> auto power(M const& elem) -> decltype(std::norm(elem)) { return std::norm(elem); }

template<class M, class = std::enable_if_t<(M::rank::value >= 1)>>
auto power(M const& array) {
    return accumulate(begin(array), end(array), 0.0, [](auto const& alpha, auto const& omega) { return alpha + power(omega); });
}

Esta é uma função de "poder" recursiva (através de dimensões ou classificações) que, em última análise, fornece a soma dos quadrados dos elementos calculando o poder dos subelementos de dimensão inferior.

O C++ moderno incentiva o uso if constexprpara evitar o uso de SFINAE, como abaixo.

template<class M>
auto power(M const& array) {
    if constexpr(M::rank::value >= 1) {
        return accumulate(begin(array), end(array), 0.0, [](auto const& alpha, auto const& omega) { return alpha + power(omega); });
    } else {
        return std::norm(array);
    }
}

O problema é que parece que a expressão no if constexprtem que ser uma expressão válida em primeiro lugar. Os elementos não possuem um tipo de membro chamado rank, portanto há um erro de compilação.

Existe algum truque para fazer o if constexprpredicado se a expressão for inválida?

Quero imprimir o intervalo de caracteres Unicode, de 00B2 a 00B5 (e muitos outros intervalos). Como posso imprimi-los programaticamente?

Obviamente, não sei como definir um caractere Unicode variável e depois fazer aritmética (incremento) para eles.

Estou procurando o loop equivalente a este abaixo.

Como posso imprimir programaticamente um intervalo arbitrário de caracteres Unicode?

#include <iostream>

int main() {

    std::cout << "\u00B2" << std::endl;
    std::cout << "\u00B3" << std::endl;
    std::cout << "\u00B4" << std::endl;
    std::cout << "\u00B5" << std::endl;

}

saída (caracteres unicode)

²
³
´
µ