All perguntas(coding)

nas palestras de Mike Actons aqui e aqui (os links têm carimbos de data/hora), bem como nesta postagem do blog, eles preparam/pré-condicionam/pré-buscam/consultam dados não contíguos necessários primeiro para depois iterá-los/fazer cálculos de uma forma amigável ao cache.

Aqui está o código da postagem do blog:

// objects_store.h

struct ObjectsStore
{
    vector<Vector3D> m_Positions;
    vector<Quaternion> m_Orientations;
};

// Runtime solution:

struct TranslationData
{
    Vector3D m_ObjPosition;
    const Quaternion m_ObjOrientation;
    const Vector3D m_ObjTranslation;
};

void PrepareTranslations(const ObjectsStore& inStore,
                         const vector<Vector3D>& inTranslations,
                         vector<TranslationData>& outObjectsToTranslate)
{
    assert(inStore.m_Positions.size() == inStore.m_Orientations.size());
    assert(inStore.m_Positions.size() == inTranslations.size());
    for (size_t i = 0; i < inTranslations.size(); ++i)
    {
        outObjectsToTranslate.push_back
        ({ 
             inStore.m_Positions[i];
             inStore.m_Orientations[i];
             inTranslations[i];
        });
    }
}

void TranslateObject(vector<TranslationData>& ioObjectsToTranslate)
{
    for (TranslationData& data: ioObjectsToTranslate)
        data.m_ObjPosition += data.m_ObjOrientation * data.m_ObjTranslation;
}

void ApplyTranslation(const vector<TranslationData>& inTranslationData
                      ObjectsStore& outStore)
{
    assert(inStore.m_Positions.size() == inTranslationData.size());
    for (size_t i = 0; i < inTranslationData.size(); ++i)
        outStore.m_Positions[i] = inTranslationData[i].m_ObjPosition;
}

void UpdateGame(ObjectsStore& ioStore, vector<Vector3D>& inTranslations)
{
   vector<TranslationData> translation_data;
   PrepareTranslations(ioStore, inTranslations, translation_data);
   TranslateObject(translation_data);
   ApplyTranslation(translation_data, ioStore);
}

Minha pergunta é: para preparar os dados dessa maneira, é preciso acessá-los de qualquer maneira (e também copiá-los), então me pergunto se, mesmo que os dados sejam mais amigáveis ​​ao cache depois , não seria mais eficiente modificá-los diretamente e poupar a etapa de preparação?

Até onde eu entendo, obviamente os cálculos são muito eficientes nos dados preparados, mas com o custo adicional de prepará-los em primeiro lugar.

Alguém pode me dizer o que estou esquecendo aqui? Alguém assume o custo extra para obter outros benefícios (como código mais claro etc.) ou é realmente mais eficiente do que a modificação direta?

desde já, obrigado

Sou novo em Haskell e tive uma tarefa de casa da universidade que compilava apenas tendo uma linha consistindo apenas de um único ponto e vírgula. Estou curioso, se esse é o comportamento pretendido e, se sim, por quê?

(Eu produzi linhas de código interessantes nos últimos dias que não estavam funcionando como esperado, cada uma era uma pequena palestra, por exemplo, --|não era uma guarda comentada, mas um operador indefinido, etc.)

A única versão que consegui fazer funcionar é (código completo abaixo):

   case input of {
       ... -- some other code
       ('0':xs)     -> [(next Zero, rest)] where (next, rest) = readAll xs
       ;
       ... -- some other code
   }

Gostaria de saber se é possível fazer isso sem uma linha composta por um único ponto e vírgula e por que os exemplos abaixo não funcionaram.

Eu tentei, por exemplo

       ('0':xs)     -> [(next Zero, rest)] where (next, rest) = readAll xs;

       ('0':xs)     -> [(next Zero, rest)] where (next, rest) = (readAll xs);

       ('0':xs)     -> [(next Zero, rest)]
          where
             (next, rest) = (readAll xs);

mas todos eles levaram ao mesmo tipo de erro:

file.hs:19:8: error: parse error on input ‘(’
   |
19 |        ('1':xs)     -> [(next One , rest)] where (next, rest) = readAll xs
   |        ^

Um trecho de código executável:

data BinaryDigit = Zero | One
data BinaryNumber = L BinaryDigit -- L: last digit
                  | E BinaryDigit BinaryNumber -- E: intermediate digit

instance Show BinaryNumber where
   show (L Zero) = "0"
   show (L One ) = "1"
   show (E digit next) = show (L digit) ++ show next

instance Read BinaryNumber where
     -- idea:
     --   next item must be known to decide whether E or L constructor to use
     --   create function that will be called on the next element and returns the right constructor,
     --   with only one parameter, the current digit value, unset
   readsPrec _ input = case input of {
       ('0':'0':xs) -> readsPrec 0 ('0':xs);
       ('0':'1':xs) -> readsPrec 0 ('1':xs);
       ('0':xs)     -> [(next Zero, rest)] where (next, rest) = readAll xs
       ;
       ('1':xs)     -> [(next One , rest)] where (next, rest) = readAll xs
       ;
       otherwise    -> [];
   } where
     readAll :: String -> (BinaryDigit -> BinaryNumber, String)
     readAll ('0':xs) = ((`E` (next Zero)), rest) where (next, rest) = readAll xs
     readAll ('1':xs) = ((`E` (next One )), rest) where (next, rest) = readAll xs
     readAll str      = (L, str)

main = putStrLn $ show (read "110" :: BinaryNumber)

Parece uma pergunta trivial a julgar pelo uso típico do &operador, mas há uma garantia do padrão de que address-of-operator não pode retornar nullptrao tentar obter um endereço?

Esta função retornará um Eithertipo. A String representa o valor de erro, e o Right/Bool representa o tipo booleano normal que o usuário se importa

testPre :: Rational -> Rational -> Either String Bool
testPre a b
  | b == 0 = Left "Shouldn't be 0" 
  | a > b = Right True
  | a <= b = Right False

Mas e se eu quisesse testar uma lista de números com um anyor especial allque funciona com Either String Bool ? Make anyor allfunciona no contexto de Either?

all (testPre 3)  [1,2]  =>  should be `Right True`
all (testPre 3)  [1,2,3]  =>  should be `Right False`

any (testPre 3)  [1,5]  =>  should be `Right True`
any (testPre 3)  [5,6]  =>  should be `Right False`

any (testPre 3)  [1,0,3]  =>  should be "Shouldn't be 0" 

Obrigado

Quero que o texto (nesse caso dentro de um <h1>) tenha um fundo colorido, onde os limites direito e esquerdo sejam inclinados. Algo assim:

Eu sei que eu deveria fazer isso definindo um fundo como linear-gradient(102deg, #ffffff00 5%, lightblue 5% 95%, #ffffff00 95%);(que eu usei para este exemplo), mas eu não consigo acertar os limites esquerdo e direito. Eu acho que o problema é que eu preciso definir valores de início e fim para o gradiente (5% e 95% neste exemplo), mas isso significa que dependendo do comprimento do texto, a transição é "em algum lugar".

h1 span {
  background: linear-gradient(102deg, #ffffff00 5%, lightblue 5% 95%, #ffffff00 95%);
  padding-left: 0.8rem;
  margin-right: 1rem;
}

<h1> <span> This is a title </span> </h1>

JSFiddle

Note que tive que mexer manualmente padding-lefte, margin-rightde alguma forma, fazer com que parecesse aceitável (mesmo que haja muito espaço à direita de "título"?).

Se eu aumentar o texto, o mesmo CSS produz isto:

Provavelmente isso ocorre porque 5% e 95% da <span>largura do 's agora estão em posições diferentes, certo?

O que eu gostaria é de uma solução que:

• Sempre funciona independentemente do comprimento do texto
• Permite-me controlar o ângulo de inclinação (12° neste caso)
• Não distorce o texto em si
• Funciona com texto multilinha
• Não corta o fundo inclinado (veja o limite direito do segundo exemplo acima)
• Tem um pequeno espaço entre a primeira letra e o limite esquerdo da caixa de fundo, e a mesma quantidade de espaço entre a última letra e o limite direito da caixa de fundo.

Tentei definir os limites para " linear-gradientto " 0.001%e 99.999%"or" algo, mas isso essencialmente remove as bordas inclinadas:

O Melhor Truque de Regex é sobre escrever regexes que correspondem, r1mas não r2. O exemplo que eles dão é um regex que corresponde a Tarzan(e "Tarzan and Jane"), mas não "Tarzan". Depois de passar por algumas coisas que não funcionam, eles dão o "melhor truque de regex de todos os tempos":

"Tarzan"|(Tarzan)

Isso supostamente corresponde à "string ruim" primeiro, pulando a string boa, mas não incluindo a string ruim em um grupo de captura. Se apenas a string boa aparecer, nós correspondemos nela por último e a incluímos no grupo de captura.

Uma desvantagem do "melhor truque de regex" é que isso ainda corresponde a "Tarzan" , mesmo que não o capture . Você não pode, por exemplo, usá-lo em um condicional sem algum boilerplate extra?

Isto é baseado em regexes estilo PCRE. O Raku usa uma notação regex completamente diferente. É possível fazer o truque de forma mais simples? Idealmente, isto deveria ser possível:

> ('"Tarzan"', 'Tarzan', '"Tarzan and Jane"') <<~~>> /some-regex/
(Nil ｢Tarzan｣ ｢Tarzan｣)

Sou novo em conceitos e intervalos/visões.

Estou tentando escrever a inicialização de uma classe passando uma sequência de valores definidos por um iterador ou por um intervalo/visualização.

Eu consigo verificar se os argumentos da função são iteradores ou intervalos. Mas não consigo verificar se os valores retornados pelos iteradores são de um tipo específico.

Por exemplo (C++23):

#include <print>
#include <vector>

struct Data {
    int i;
    std::string l;
};

struct DataContainer {
    // iterator version
    // QUESTION: how can I check that I handles "Data"?
    template<std::input_iterator I, std::sentinel_for<I> S>
    void add(I start, S end) {
        for (auto data = start; data != end; ++data) {
            _data.push_back(*data);
        }
    }
    // range/views version
    // QUESTION: how can I check that R handles "Data"?
    template<std::ranges::input_range R>
    void add(R &&r) {
        add(std::begin(r), std::end(r));
    }
    void dump() const {
        for (const auto& d: _data){
            std::print("[{},'{}'], ", d.i, d.l);
        }
        std::println();
    }
    std::vector<Data> _data;
};

int main()
{
    std::vector<Data> init{{1, "one"}, {2, "two"}, {3, "three"}};
    {
        DataContainer dc;
        dc.add(init.begin(), init.end());
        dc.dump();
    }
    {
        DataContainer dc;
        dc.add(init);
        dc.dump();
    }
    return 0;
}

Como posso verificar se *startretorna um Data?

Considere o seguinte código:

#include <iostream>
#include <string>

union U
{
    std::string s;

    U()
    {
        new(&s) std::string;
    }

    void Set(std::string new_s)
    {
        s.~basic_string();
        new(&s) std::string(std::move(new_s));
    }

    ~U()
    {
        s.~basic_string();
    }
};

int main()
{
    U u;
    u.Set("foo");
    std::cout << u.s << '\n'; // Do I need `std::launder` here?
}

Eu sei que se eu usasse um array de bytes em vez de uma união, eu teria que std::launder(&s)acessar a string. Mas eu preciso disso aqui?

A resposta do senso comum parece ser "não", mas então onde está a bênção padrão unionde não precisar std::launder?

Em C++20, subsunção de conceito se refere a um conceito sendo um superconjunto de outro conceito. Por exemplo, no exemplo a seguir, Fooablesubsumes BetterFooable:

template <typename T>
concept Fooable = requires(T& t) {
    t.foo();
};

template <typename T>
concept BetterFooable = Fooable<T> && requires(T& t, int x) {
    t.foo(x);
};

O compilador é capaz de ver que BetterFooableé definido como Fooable e outra coisa e, portanto, qualquer tipo que satisfaça BetterFooabletambém deve necessariamente satisfazer Fooable.

Isso nos permite especializar parcialmente as classes de modelo:

template <Fooable T1>
struct MyStruct1 {};
template <BetterFooable T1>
struct MyStruct1<T1> {};

Entretanto, uma especialização de uma classe com um pacote de parâmetros de modelo parece não ser aceitável nem no GCC nem no Clang, mas aceitável no MSVC ( link godbolt ):

template <Fooable... Ts>
struct MyStruct2 {};

template <BetterFooable... Ts>
struct MyStruct2<Ts...> {};

O erro produzido pelo GCC está abaixo, e o erro produzido pelo Clang é muito semelhante:

<source>:15:8: error: partial specialization 'struct MyStruct2<Ts ...>' does not specialize any template arguments and is not more constrained than the primary template; to define the primary template, remove the template argument list
   15 | struct MyStruct2<Ts...> {};
      |        ^~~~~~~~~~~~~~~~
<source>:12:8: note: primary template here
   12 | struct MyStruct2 {};
      |        ^~~~~~~~~

O GCC e o Clang estão corretos em rejeitar esse código? E há alguma maneira alternativa de expressar a subsunção de conceitos em pacotes de parâmetros de modelo?

Gostaria de ter uma sobrecarga de função em que um caso de uso passa o argumento não-matriz por ponteiro, e o outro caso de uso passa o argumento C-matriz por referência.

Infelizmente, a passagem de um argumento de matriz C seleciona ambas as funções candidatas porque o decaimento do ponteiro da matriz C deve estar no mesmo nível de consideração, tornando a situação ambígua.

#include <iostream>

static void foo(int* p) {
    std::cout << "int* -> " << *p << "\n";
}

static void foo(int (&a)[4]) {
    std::cout << "int[4] -> "
        << a[0] << " "
        << a[1] << " "
        << a[2] << " "
        << a[3] << "\n";
}

int main() {
    int array[4]{ 10, 20, 30, 40 };
    foo(array); // error: call to 'foo' is ambiguous
    foo(array + 3);
}

Atualmente estou usando esta solução alternativa. Não estou satisfeito com esta solução alternativa.

static void foo(int (*a)[4]) { /*...*/ }

...que seria chamado via...

    foo(&array);

A alternativa de alterar a passagem por ponteiro para passagem por referência a ponteiro void foo(int*& p)impediria chamá-lo por, foo(array + 3)já que é um rvalue.

Existe outra abordagem (ou modelo mágico) que poderia esclarecer as duas situações?

O contexto é preferencialmente C++17, mas se uma solução decente puder ser expressa em C++20 ou posterior, isso ainda seria interessante.

(Problema XY?) O contexto original era a passagem de argumento de um ponteiro ou array como um parâmetro de construtor de classe. O contexto original é uma tentativa de fazer um "ponteiro gordo", como o Miracle Pointer do Google, que é um substituto drop-in de ponteiro de um ponteiro bruto regular, mas contém informações de span e offset e verificações de paranoia (o que incorre em sobrecarga adicional de tempo de execução). Tentei simplificar o exemplo para o caso de reprodução saliente e mínimo.

ATUALIZAÇÃO (respondendo ao comentário): por fim, gostaria que ele também suportasse e distinguisse a const int[4]e a const int*também.