edrezen's questions

Tenho um projeto antigo do Vaadin14 que costumava funcionar com o Java 1.8.

Atualizei minha distribuição Linux e agora o Java é a versão 21.

O problema agora é que quando tento construir o projeto (com mvn package -Pproduction), recebo o seguinte erro:

[ERROR] Failed to execute goal com.vaadin:vaadin-maven-plugin:14.9.5:build-frontend (default) on project org-cubr-ui-vaadin: Execution default of goal com.vaadin:vaadin-maven-plugin:14.9.5:build-frontend failed: Unsupported class file major version 65 -> [Help 1]

Então instalei o Java 1.8 e o tornei a versão padrão, update-alternatives --config javamas ainda tenho o mesmo erro ao compilar o projeto.

Pergunta 1: Por que o maven não usa a versão java configurada com update-alternatives? Tenho algo para modificar no pom.xmlarquivo ?

Pergunta 2: É possível construir um projeto Vaadin14/maven em uma distribuição recente (quero dizer, com uma versão recente do Java)?

Atualização: ao iniciar o maven com a opção -X, posso ver logo no início que o java 21 é usado.

Este post fala sobre um método que conta o número de membros de uma classe:

struct UniversalType { template<typename T> operator T();  };

template<typename T, typename... A0>
consteval auto MemberCounter(auto ...c0) 
{
    if constexpr (requires { T{ {A0{}}..., {UniversalType{}}, c0... }; } == false
               && requires { T{ {A0{}}..., c0..., UniversalType{}   }; } == false )
   {
        return sizeof...(A0) + sizeof...(c0);
    }
    else if constexpr (requires { T{ {A0{}}..., {UniversalType{}}, c0... }; })
    {
        return MemberCounter<T,A0...,UniversalType>(c0...);
    }
    else
    {
        return MemberCounter<T,A0...>(c0...,UniversalType{});
    }
}

using TestType = struct { int x[3]; float y; char z; };
static_assert (MemberCounter<TestType>() == 3);

int main() {}

Em particular, as duas requirescláusulas a seguir me intrigam um pouco, pois misturam chaves simples e duplas:

1. requires { T{ {A0{}}..., {UniversalType{}}, c0... }; }
2. requires { T{ {A0{}}..., c0..., UniversalType{} }; }

Pergunta: que tipo de itens eles permitem combinar exatamente?

Quero definir uma opção de compilação -DVAR=xxx. Eu sei que posso fazer isso, target_compile_optionsmas meu problema é que o valor xxxdeve ser gerado dinamicamente e só está disponível como conteúdo de um arquivo txt.

Aqui está minha tentativa:

1. crie um comando personalizado que gere o arquivo contendo o valor a ser usado
2. crie um destino personalizado que permita construir o var.txtarquivo
3. crie uma dependência para ter certeza de que var.txtserá gerado antes da compilação doMyExe

mas não sei como recuperar o valor necessário do arquivo e usá-lo em target_compile_options.

cmake_minimum_required(VERSION 3.13)

project ("MyProject")

add_custom_command (
  OUTPUT  var.txt
  COMMAND echo "123" > var.txt      # just an example here, the real generation is more complex
  COMMENT "Generate variable value"
)

add_executable         (MyExe main.cpp)
target_compile_options (MyExe PUBLIC -DVAR=???)  # how to get the content of "var.txt" for setting VAR ?

add_custom_target (var   ALL DEPENDS var.txt)
add_dependencies  (MyExe  var)

É possível target_compile_optionsusar valores recuperados de um arquivo gerado?

Considere a seguinte constante de tempo de compilação VALUEdefinida por

struct foo  {  uint32_t a;  };

static constexpr int VALUE = sizeof(foo);

Observe que a forma como o valor é calculado não é importante aqui.

Gostaria de recuperar o próprio valor (4 no exemplo) como resultado da compilação ; em outras palavras, não quero construir um binário e iniciá-lo para obter esse valor.

Sei que essa opção -Epermite parar após o pré-processamento mas nesta fase o valor ainda não é conhecido. Talvez exista alguma opção de compilador que permita isso, mas não sei.

A única maneira que consigo pensar é colocar um static_assert(VALUE==-1)que causará um erro e esperar que a mensagem de erro mantenha o valor; parece que gccpode fazer isso, mas não clang.

Existe uma maneira melhor e não dependente do compilador de obter o valor constante como resultado da própria compilação?

Eu defini a seguinte estrutura de modelo:

template<typename T>  struct somestruct {}; 

e agora as seguintes especializações:

template<typename T> struct somestruct <std::vector<T>>                {};  // OK
template<typename T> struct somestruct <decltype(std::vector<T>  {})>  {};  // KO

Porém, a última especialização não compila com o seguinte erro (veja aqui ):

error: template parameters not deducible in partial specialization:

Ingenuamente, diria que as duas especializações não são tão diferentes, como parece dizer o seguinte:

template<typename T> void test ()  
{ 
    static_assert (std::is_same_v<std::vector<T>, decltype(std::vector<T>{})> );
}

Pergunta: qual o motivo técnico que faz o compilador falhar com a segunda especialização? E existe uma maneira de consertar isso (quero dizer, meu código, não o compilador)?

Há um post antigo que parece semelhante, mas talvez coisas/compilador/c++ possam ter mudado.

Com a especialização de modelo, é possível codificar características que recebem uma lista de tipos, aplicar uma transformação em cada tipo que retorna um booleano e, em seguida, avaliar uma expressão final que é um andem todos os resultados da transformação:

#include <type_traits>

template<template<typename> class TRANSFO, typename ...ARGS>
struct Eval {};

template<template<typename> class TRANSFO, typename T, typename ...ARGS>
struct Eval<TRANSFO, T, ARGS...>
{
    static constexpr bool value = TRANSFO<T>::value and Eval<TRANSFO,ARGS...>::value;
};

template<template<typename> class TRANSFO>
struct Eval<TRANSFO>
{
    static constexpr bool value = true;
};

int main()
{
    static_assert (Eval<std::is_integral,int,long>::value == true);
    static_assert (Eval<std::is_integral,int,float,long>::value == false);
    static_assert (Eval<std::is_integral,float>::value == false);
}

A pergunta já tem stdtal coisa? Ou é possível escrevê-lo com características existentes em std?

No código a seguir, tento usar um vetor v1feito de referências de um tipo e um vetor v2feito de uma referência de um tipo:

#include <string>
#include <vector>

int main (int argc, char* argv[])
{
   std::string  object ("foobar");
   std::string& refobj = object;

   std::vector<std::reference_wrapper<decltype(object)>> v1;

   // The following line doesn't compile => error: forming pointer to reference type ‘std::__cxx11::basic_string<char>&
   std::vector<std::reference_wrapper<decltype(refobj)>> v2;
   
   std::vector<std::reference_wrapper<std::remove_reference_t<decltype(refobj)>>> v3;
}

Como esperado, o código é compilado para, v1mas não para v2, o que também deve estar ok, IMHO; nesse caso, o wrapper de referência não deve fazer nada, pois o tipo fornecido já é uma referência.

Observe que posso conseguir o que desejo com o vetor, v3mas o código parece um pouco complicado.

Pergunta : por que o compilador não fica satisfeito durante a compilação v2? Em outras palavras, por que devo primeiro remover a referência de tipo antes de adicionar uma com reference_wrapper?

Eu tenho uma estrutura de modelo Fooque define uma estrutura interna Bar.

Agora, gostaria de sobrecarregar o fluxo operator <<para esta struct interna Bar, mas o compilador parece ignorar minha implementação de sobrecarga:

erro: nenhuma correspondência para 'operator<<' (os tipos de operando são 'std::ostream' {também conhecido como 'std::basic_ostream<char>'} e 'Foo<3>::Bar')

Meu código é o seguinte:

#include <iostream>

//////////////////////////////////////////////////////////////////////////////////////////
template<int N>
struct Foo
{
    struct Bar  {};
};

//////////////////////////////////////////////////////////////////////////////////////////
template<int N>
std::ostream& operator<< (std::ostream& os, const typename Foo<N>::Bar& x)
{
    return os;
}

//////////////////////////////////////////////////////////////////////////////////////////
int main (int argc, char** argv)
{
    Foo<3>::Bar x;

    std::cout << x << std::endl;
}

Não consigo ver o erro (talvez óbvio).

Pergunta É possível sobrecarregar um operador de uma estrutura interna que pertence a uma classe template?