Início / user-1947241

Derek's questions

Martin Hope
Derek
Asked: 2025-04-07 09:34:08 +0800 CST
  • 8

Estou explorando o recurso "deduzindo isso" e estou com dificuldades para entender como usá-lo corretamente com conceitos. Aqui está o que eu tenho:

#include <concepts>

struct X {
  X() = default;
  X& operator+=(int x) { value += x; return *this; }
  int value = 0;
};

struct Y {
  Y() = default;
  template<typename Self> Self& operator+=(this Self& self, int x) {
    self.value += x; return self;
  }
  int value = 0;
};

template<typename T, typename U>
concept has_addition_assignment =
  std::is_lvalue_reference_v<T>
  && requires(T a, U b) { { a += b } -> std::same_as<T>; };

static_assert(has_addition_assignment<X&,int>); // OK
static_assert(!has_addition_assignment<const X&,int>); // OK

static_assert(has_addition_assignment<Y&,int>); // OK
// static_assert(!has_addition_assignment<const Y&,int>); // Fails

int
main()
{
  // Not allowed.
  //  const Y y;
  //  y += 1;
}

O conceito é tentar garantir que X x; x += 1;funcione, mas const X x; x += 1não funciona. Isso funciona para, Xmas não funciona Y, apesar de const Y y; y += 1;falhar.

Acredito que meu conceito está escrito incorretamente ou talvez +=não Yexpresse minha intenção corretamente. Qual é a melhor maneira de verificar se não é aceitável adicionar algo a um objeto constante ao usar deducing this?

c++
Martin Hope
Derek
Asked: 2024-12-25 10:52:54 +0800 CST
  • 8

Não tenho certeza se estou entendendo errado requiresou se o clang tem um bug. Aqui está o código:

#include <cassert>
#include <concepts>

template<std::unsigned_integral T>
constexpr unsigned int
foo(T x)
{
    return x;
}

template<std::unsigned_integral T> requires (sizeof(T) == 1)
constexpr unsigned int
foo(T x)
{
    return x + 1;
}

int
main()
{
    assert(foo(static_cast<unsigned char>(0)) == 1);

    unsigned int (*function)(unsigned char x) = foo;
    assert(function(0) == 1);
}

clang -vdiz

Apple clang version 16.0.0 (clang-1600.0.26.6)
Target: arm64-apple-darwin24.2.0

e compilar e executar isso como clang -std=c++20 file.cc -o file; fileproduz

Assertion failed: (function(0) == 1), function main, file file.cc, line 24.
Abort trap: 6

Isso me confunde: por que o compilador escolheria instanciações diferentes? Em ambos os casos, eu esperaria uma chamada para unsigned int foo<unsigned char> (unsigned char x), mas talvez eu esteja entendendo errado o que deveria acontecer.

c++