Chameleon's questions

De acordo com a especificação OpenMP (2.1. Formato de Diretiva)

Diretivas não podem aparecer em funções constexpr ou em expressões constantes. Pacotes de parâmetros variádicos não podem ser expandidos para uma diretiva ou suas cláusulas, exceto como parte de um argumento de expressão a ser avaliado pela linguagem base, como em uma chamada de função dentro de uma cláusula if.

Eu uso bastante o OpenMP em funções constexpr até que o g++14.2 sem compilador emitiu um aviso. Mas usar o g++15 é um erro.

O seguinte não é um erro do g++14.2, mas sim um erro do g++15.

erro: diretivas OpenMP podem não aparecer em funções 'constexpr' [-Wtemplate-body]

constexpr void func(size_t sz) noexcept
{
     #ifdef _OPENMP
     #pragma omp parallel for
     #endif
     for (size_t i = 0; i < sz; ++i) something(i);
}

Qual é o motivo dessa restrição? O compilador tem a capacidade de executar código compatível com OpenMP sem habilitar o OpenMP. Esqueci de alguma coisa?

Estou tentando corrigir meu código com a seguinte solução alternativa. O g++15 não proíbe isso, mas não sei se ele quebra novamente o padrão OpenMP e, por exemplo, no g++16, preciso corrigir meu código novamente.

O seguinte é aceito pela especificação OpenMP? É aceito pelo g++15 (e anteriores).

constexpr void func(size_t sz) noexcept
{
    auto fcommon = [](size_t i) {};
    auto fomp    = [sz]()
    {
         #ifdef _OPENMP
         #pragma omp parallel for
         #endif
         for (size_t i = 0; i < sz; ++i) fcommon(i);
    };
    auto fseq    = [sz]() { for (size_t i = 0; i < sz; ++i) fcommon(i); };

    if (std::is_constant_evaluated()) fseq(); else fomp();
}

Como posso especificar o tipo de retorno de uma função com um autotipo de retorno inferido ( ), quando o corpo contém várias if constexprramificações e uma delas lança incondicionalmente?

O tipo de retorno deve satisfazer um certo conceito; não posso simplesmente deixá-lo como void.

Tentei usar, std::declvalmas o g++ static me afirma com "você não pode usar declval".

A questão é: existe alguma abordagem melhor para declarar um tipo de retorno do que um retorno falso?

auto func()
{
   if constexpr (A)
   {
      if (...) return std::vector<int>{}; // actually something difficult to initialize
   }
   if constexpr (A && C)
   {
      throw 5;
      // fake return to declare return type - same type as if constexpr (A) above
      // return std::move(std::declval<std::vector<int>>()); // static assert in std library
      return std::move(*static_cast<std::vector<int>*>(nullptr)); // it works! is there any better way?
   }
   else return std::array<double, 5>{}; 
}

Assisti a um vídeo do Scott Meyers sobre referências universais e ele disse que sempre que você usar uma referência universal, deverá encaminhá-la assim:

template<typename T>
auto func(T &&a) { return ++std::forward<T>(a); }

Então deduzindo thistemos:

auto member_func(this auto &&self) { return self.member_variable; }

Onde está o std::forward<???>(self).member_variableaqui? O que eu perdi?

Cheguei ao C e C++ vindo do Assembly antes de 2,5 décadas.

Herdei algumas coisas implícitas no assembly, tanto para C quanto para C++, mas depois percebi que essas coisas são, na verdade, um comportamento indefinido.

Uma delas foi a diferença entre delete ptre delete[] arraywhich para o sistema operacional geralmente é uma chamada porque não há destruidores.

Minha última suposição é o seguinte código:

std::byte *a = new std::byte[10];
short *b = reinterpret_cast<short*>(a);
delete[] b;

Esse comportamento é indefinido? Não existem destruidores.

Obtenho sizeof()resultados estranhos [[no_unique_address]]no g++ 13.2.

#include <iostream>

using namespace std;

template<bool T>
struct B
{
    struct Dummy {};

    int *a; // swap position with <below placemark>
    // In this position, results are "16" and "40".
    
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> y;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> x;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> h;
    [[no_unique_address]] std::conditional_t<T, Dummy, size_t> w;
    
    // <below placemark>
    // In this position, results are "8" and "40".
    
};

int main()
{
    cout << sizeof(B<true>) << "\n";
    cout << sizeof(B<false>) << "\n";
}

O resultado é

16
40

mas se você mudar int *a;para a posição após as [[no_unique_address]]linhas, você obterá

8
40

Além disso, com apenas uma [[no_unique_address]]linha e com a variável de ponteiro de membro antes, os resultados estão corretos:

8
16

Eu li a documentação, [[no_unique_address]]mas não faço nada específico.

Por que isso acontece?