Perguntas[c++](coding)

Fiz alguns modelos que supostamente

• (1) testar se os números podem ser adicionados sem estouro,
• (2) somar números e falhar em caso de estouro.

O (1) test_sumdentro static_assertcompila, então acho que é constexpr.
Eu queria evitar duplicar os cálculos, então tentei colocar a declaração diretamente dentro da função (2) que calcula a soma. No entanto, a declaração sempre falha, independentemente da condição, em todas as versões abaixo. Isso pode ser resolvido de alguma forma?

#include <limits>
#include <stdexcept>
#include <type_traits>

template<typename T>
constexpr bool add(T& a, T b)
{
    static_assert(std::is_integral<T>::value, "Only integral types are supported");

    if ((b > 0) && (a > std::numeric_limits<T>::max() - b))
        return false;
    if ((b < 0) && (a < std::numeric_limits<T>::min() - b))
        return false;

    a += b;
    return true;
}

//

template<typename T>
constexpr bool sum_impl(T& result)
{
    return true;
}

template<typename T, typename... Rest>
constexpr bool sum_impl(T& result, T value, Rest... rest)
{
    if (!add(result, value))
        return false;

    return sum_impl(result, rest...);
}

//

template<typename T, typename... Rest>
constexpr bool test_sum(T value, Rest... rest) // (1)
{
    return sum_impl(value, rest...);
}

template<typename T, typename... Rest>
T sum(T value, Rest... rest) // (2) regular
{
    if (!sum_impl(value, rest...))
        throw std::overflow_error("Overflow in checked::sum");

    return value;
}

template<typename T, typename... Rest>
constexpr T sum_cexpr(T value, Rest... rest) // (2) constexpr
{
//  if (!sum_impl(value, rest...))
//      static_assert(false, "Overflow"); // fail

//  static_assert(sum_impl(value, rest...), "Overflow"); // fail

//  if (!sum_impl(value, rest...))
//      delegated_assert<false>(); //  fail

    return value;
}

template<bool B>
constexpr void delegated_assert()
{
    if constexpr (!B)
        static_assert(B);
}

//////

int main()
{
    static_assert(test_sum(1, 2)); // (1) works

    constexpr int a = sum_cexpr(10, 20, 30); // fails to compile
    
    return 0;
}

Estou brincando com o Pico SDK e a extensão no VS Code e parece que, quando produzo um programa em C++ em vez de C, várias opções de hardware não estão mais disponíveis para inclusão. Especificamente no meu caso, gostaria de usar o ADC.

#include "hardware/adc.h"

Isso funcionou bem com um programa C, mas não está mais disponível em C++.

 fatal error: hardware/adc.h: No such file or directory

Por que isso acontece e há algo que eu possa fazer a respeito? Eu preferiria usar C++ para meus programas, pois quero usar algumas das bibliotecas padrão incluídas em C++ e, para mim, é mais intuitivo.

O padrão exige que isso operator->()seja definido para iteradores não contíguos do tipo past-the-end?

Fundo:

• Independentemente da categoria do iterador, é permitido operator*()exibir comportamento indefinido quando o iterador aponta para o passado-do-fim. Isso é explícito em https://en.cppreference.com/w/cpp/iterator , seção "Desreferenciabilidade e validade", que diz: "Valores de um iterador i para os quais a expressão *i é definida são chamados desreferenciáveis. A biblioteca padrão nunca assume que valores passado-do-fim são desreferenciáveis."
• EDIT: A conclusão neste tópico está errada: veja minha resposta abaixo. Para iteradores contíguos , acredito que não é permitido operator->()exibir comportamento indefinido quando o iterador aponta para o passado-do-fim. Isso pode ser inferido de duas seções em cppreference: (1) Em https://en.cppreference.com/w/cpp/iterator/contiguous_iterator , a seção "Requisitos semânticos" define o iterador não desreferenciável ce estabelece requisitos para std::to_address(c)os quais implica que std::to_address(c)não exibe comportamento indefinido. (2) em https://en.cppreference.com/w/cpp/memory/to_address, ele fornece uma "Possível implementação" onde std::to_addressdepende de operator->(). EDIT: A "possível implementação" não usa operator->()caso pointer_traitsseja definida para o iterador; se for esse o caso, parece permitido operator->()não ser definida para iteradores finais.

É menos claro se iteradores não contíguos podem implementar operator->()de forma que seu comportamento seja indefinido para iteradores que terminam no final. Aqui estão várias "evidências"/"dicas" que encontrei relacionadas a isso:

• Conceitos de iteradores C++20 não contíguos parecem não exigir que isso operator->()seja definido. Isso simplesmente não é mencionado entre todos os requisitos definidos em https://en.cppreference.com/w/cpp/iterator/random_access_iterator , ou os requisitos dos quais dependem, AFAICS.
• O conceito de iterador contíguo em C++20, std::contiguous_iterator, requer operator->(): como mencionado acima, isso pode ser inferido, pois std::to_addressdeve ser definido, e a "Possível implementação" para std::to_addressusos operator->(). E a página https://en.cppreference.com/w/cpp/memory/to_address menciona explicitamente std::contiguous_iterator. Como não menciona outros tipos de iteradores, isso não implica nada para iteradores não contíguos, se bem me lembro.
• As categorias de iteradores legados exigem que operator->()seja definido para LegacyInputIteratore mais forte (veja a tabela em https://en.cppreference.com/w/cpp/named_req/InputIterator ) e isso é qualificado pela "Pré-condição: i é desreferenciável". Em outras palavras, há uma exceção explícita que permite que iteradores que terminam no passado exibam comportamento indefinido. Não vejo essa pré-condição removida para nenhuma das categorias de iteradores legados mais fortes (a propósito, nem mesmo https://en.cppreference.com/w/cpp/named_req/ContiguousIterator , então isso parece uma diferença entre LegacyContiguousIteratore std::contiguous_iterator).
• Por outro lado, em https://en.cppreference.com/w/cpp/iterator , seção "Desreferenciabilidade e validade", menciona-se que ______ operator*()não precisa ser definido para iteradores que terminam no passado, mas não menciona _______ operator->(). Portanto, isso pode sugerir que a exceção que permite que algumas operações em iteradores que terminam no passado sejam indefinidas não se aplica necessariamente a operator->()_______.

Portanto, é fácil se confundir, e vejo bastante "evidência"/"dicas" relacionadas a iteradores não contíguos, operator->()e passado-do-fim. Mas não há nenhum requisito explícito, até onde consegui encontrar, que determine se iteradores não contíguos podem exibir comportamento indefinido quando operator->()o iterador aponta para passado-do-fim. Alguém tem uma resposta mais definitiva?

Editar : Obrigado por vários comentários úteis. Para dar um contexto, possivelmente respondendo a algumas das respostas: O lado prático, um pouco simplificado, é que eu defini wrappers de iteradores , ou seja, classes de iteradores personalizadas cuja implementação depende de um iterador existente ("encapsulado"). O tipo do iterador encapsulado é fornecido como um parâmetro de modelo e o iterador encapsulado é fornecido como um argumento do construtor. Eu, descuidadamente, presumi que poderia definir operator->()na classe encapsuladora como &*wrapped_iterator. Isso funcionou no clang, gcc, na compilação de lançamento do MSVC e até mesmo na compilação de depuração do MSVC para iteradores não contíguos. No entanto, resultou em falhas de asserção na compilação de depuração do MSVC para iteradores contíguos, em funções como std::vector::assign(first,last)onde first e last são wrappers em torno de iteradores contíguos e first e last são ambos iteradores passados ​​do fim. O motivo foi que o MSVC vector::assigninvoca std::address_of(first) even if first==last , o que eu não previ. Por sua vez, address_ofinvocado first.operator->()para o meu wrapper de iterador contíguo. Como eu havia definido operator->()como &*wrapped_iterator, ele invoca operator*o iterador encapsulado cujo comportamento sob as condições fornecidas é indefinido. Neste caso específico, resultou em uma falha de asserção, porque o modo de depuração do MSVC tem um código especial que verifica coisas como esta ( _ITERATOR_DEBUG_LEVEL).

Então, preciso alterar a implementação de operator->(). no meu wrapper de iterador. Minha primeira ideia era fazer com que ele invocasse operator->()o iterador encapsulado. No entanto, não há garantia de que isso seja definido (veja a resposta aceita). O que preciso fazer é invocar std::to_addresso iterador encapsulado.

Deixe-me começar com um C++código que simplifica os problemas que enfrentei na base de código real. Eu o compilei com --std=c++20e --std=c++17. O primeiro for-loop abaixo funcionou bem; o segundo for-loop, que retorna, std::optional<Container>não funcionou, para todos os contêineres que testei. Gostaria de entender o porquê:

#include <iostream>
#include <optional>
#include <string>
#include <unordered_set>

std::unordered_set<std::string> GenerateSet() {                                                                                                                                                                                                      
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

std::optional<std::unordered_set<std::string>> GenerateOptionalSet() {                                                                                                                                                                               
  std::unordered_set<std::string> names = {"a", "b"};                                                                                                                                                                                                
  return names;                                                                                                                                                                                                                                      
}

int main() {                                                                                                                                                                                                                                         
  std::cout << "When a set is returned: {";                                                                                                                                                                                                          
  for (const auto& e : GenerateSet()) {                                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  std::cout << "When a optional of a set is returned: {";                                                                                                                                                                                            
  for (const auto& e : GenerateOptionalSet().value()) {                                                                                                                                                                                              
    std::cout << e << " ";                                                                                                                                                                                                                           
  }                                                                                                                                                                                                                                                  
  std::cout << "}" << std::endl;                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  return 0;                                                                                                                                                                                                                                          
}

O resultado foram falhas de segmentação em tempo de execução (bastante recente clang) ou nenhuma iteração no segundo for-loop (bastante antigo gccem uma máquina Linux arcaica).

Aqui está o URL ao qual me referi em relação a std::optional<T>::value(): std::optional::value() do cppreference.com

Parece haver 4 versões diferentes. Não tinha certeza de qual versão das 4 funções substituídas seria invocada e por que não funciona como eu esperava (ou seja, apenas repetindo o valor do temporary retornado std::optional<T>).

De uma pergunta anterior, sei que ao chamar ~base()uma classe derivada, ela primeiro constrói um objeto base temporário, depois invoca a base temporária operator~()no objeto temporário e, finalmente, destrói o objeto temporário.

Entretanto, quando a classe base não tem um operator~, chamar base::~base()a classe derivada ainda pode invocar o destruidor da classe base.

Por que ocorre um erro quando a classe base tem um operator~?

#include <iostream>
using namespace std;
class base
{
public:
    base(){cout << "constructor base \n";}
    ~base(){cout << "destructor base \n";}
    void operator~(){cout << "operator ~ \n";}
};

class derived : public base
{
public:
    derived(){cout << "constructor derived \n";}
    ~derived(){base::~base();cout << "destructor derived \n";}
};

Informações sobre a versão do compilador:

g++.exe (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 8.1.0
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Erro:

cmd /c chcp 65001>nul && C:\mingw64\bin\g++.exe -fdiagnostics-color=always -g "D:\Valkyrie-text\simple text\text.cpp" -o "D:\Valkyrie-text\simple text\text.exe"
D:\Valkyrie-text\simple text\text.cpp: In destructor 'derived::~derived()':
D:\Valkyrie-text\simple text\text.cpp:15:28: error: no matching function for call to 'derived::~derived()'
     ~derived(){base::~base();cout << "destructor derived \n";}
                            ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note: candidate: 'base::~base()'
     ~base(){cout << "destructor base \n";}
     ^
D:\Valkyrie-text\simple text\text.cpp:7:5: note:   candidate expects 1 argument, 0 provided

Em C++, por que uma classe derivada não pode chamar direta e explicitamente o destruidor de sua classe base sem usar um operador de resolução de escopo?

Ouvi dizer que em C++ todos os destruidores são processados ​​pelo compilador em "destrutor", o que significa que os destruidores das classes base e derivadas têm o mesmo nome, levando à redefinição (ocultação).

Isso está correto?

#include <iostream>
 
struct base {
    base() { std::cout << "base default \n"; }
    ~base() { std::cout << "~base \n"; }
};
 
struct derived : base {
    derived() { std::cout << "derived default \n"; }
    ~derived()
    {
        //~base();No
        base::~base();
        std::cout << "~derived \n";
    }
};

Eu sei que na prática quase não há necessidade de fazer isso, só quero entender o princípio...

Estou com dificuldade para entender se realmente há diferença entre as duas afirmações:

Image->Picture->Bitmap = bitmap;  // bitmap is a TBitmap object
Image->Picture->Assign(bitmap);

A ajuda do VCL diz claramente sobre a tarefa via =:

Observação: Ao atribuir a propriedade Bitmap, TPicture atribui as propriedades de outro objeto TBitmap. Ele não assume a propriedade do valor especificado.

Isso significa que a primeira instrução NÃO copia o bitmap, masImage->Picture->Bitmap apenas o endereço do bitmapé assumido por Image->Picture->Bitmap.

Image->Picture->BitmapPor que a imagem na tela está sendo exibida corretamente mesmo depois de eu ter excluído o objeto bitmap ?

Tendo lido bastante sobre o propósito das uniões e trocadilhos de tipos (que basicamente não são permitidos e você deve confiar na otimização do compilador para eliminar chamadas memcpy), estou me perguntando se o seguinte uso de uma união é inseguro, ou se é um comportamento indefinido, ou se é, de fato, um uso perfeitamente compatível e seguro de uma união. A ideia é que os dados subjacentes sejam todos do mesmo tipo fundamental (int, double, etc.), mas eu só quero observar como eles são dispostos de maneiras diferentes ou nomeados de maneiras diferentes. Eu talvez chamaria isso de "trocadilho de contêiner" em vez de "trocadilho de tipos".

// main.cpp
// compile with `c++ main.cpp -std=c+23`

#include <iostream>
#include <array>
#include <format>


struct Mat2 {
  union {
    std::array<float, 4> data;
    std::array<std::array<float, 2>, 2> rows;
    struct { float x, y, z, w; };
  };
};


int main() {

  // sometimes you want to think about it in rows
  Mat2 m{ .rows = {{ {0, 1},
                     {2, 3} }}};

  for (auto &row : m.rows) {
    for (auto &col : row) {
      std::cout << col << " ";
    }
    std::cout << "\n";
  }

  // sometimes you want to think about it as a block of data
  std::cout << "\n";
  for (auto &d : m.data) {
    std::cout << d << " ";
  }
  std::cout << "\n\n";

  // sometimes you want to access elements based on sematic names
  std::cout << std::format("{}, {}, {}, {}", m.x, m.y, m.z, m.w);
  std::cout << std::endl;

}

Quero uma visão dos caracteres de um fluxo de entrada:

    auto input = std::stringstream{"abcd"};
    using Iter = std::istreambuf_iterator<char>;
    auto s = std::ranges::subrange{Iter{input}, Iter{}};

Até aqui, tudo bem. Agora, eu transformo essa visualização (usando uma transformação de identidade para simplificar):

    auto t = s | std::views::transform(std::identity{});

Embora esta visão transformada tenha uma validade value_type(ou seja, esta afirmação passa):

    using T = decltype(t);
    static_assert(std::is_same_v<char, std::ranges::range_value_t<T>>);

o tipo de iterador dele não tem um:

    static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);

Isso falha com

view.cc: In function 'int main()':
view.cc:27:90: error: 'value_type' is not a member of 'std::iterator_traits<std::ranges::transform_view<std::ranges::subrange<std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::ranges::subrange_kind::unsized>, std::identity>::_Iterator<false> >'
   27 |     static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);
      |                                                                                          ^~~~~~~~~~
view.cc:27:100: error: template argument 2 is invalid
   27 |     static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);
      |                   

A razão pela qual isso é importante para mim é que quero usar as características do iterador em um adaptador de visualização posterior.

A investigação sugere que o iterador da visualização de transformação não possui seu iterator_categorymembro. O código funciona bem quando passo um intervalo mais capaz, como std::stringpara a transformação, mas falha com esse intervalo não direto.

Código completo (também no Compiler Explorer ):

#include <functional>
#include <iterator>
#include <ranges>
#include <sstream>
#include <string>
#include <type_traits>

int main()
{
#ifdef PASS
    auto input = std::string{"abcd"};
    std::ranges::forward_range auto s = std::ranges::subrange(input.begin(), input.end());
#else
    auto input = std::stringstream{"abcd"};
    using Iter = std::istreambuf_iterator<char>;
    std::ranges::input_range auto s = std::ranges::subrange{Iter{input}, Iter{}};
#endif

    using S = decltype(s);
    static_assert(std::is_same_v<char, std::ranges::range_value_t<S>>);
    static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<S>>::value_type>);

    auto t = s | std::views::transform(std::identity{});
    using T = decltype(t);
    static_assert(std::is_same_v<char, std::ranges::range_value_t<T>>);
    static_assert(std::is_same_v<char, std::ranges::iterator_t<T>::value_type>);
    static_assert(std::is_base_of_v<std::input_iterator_tag, std::ranges::iterator_t<T>::iterator_category>);
    static_assert(std::is_same_v<char, std::iterator_traits<std::ranges::iterator_t<T>>::value_type>);
}

Ao tentar medir o impacto da previsão de erros de ramificação, percebi que não há nenhuma penalidade na previsão de erros de ramificação.

Com base na famosa pergunta de estouro de pilha: Por que processar um array ordenado é mais rápido do que processar um array não ordenado?

Escrevi um trecho simples de código para medir a penalidade da previsão de ramificação.

• Preencha uma matriz com números aleatórios
• Conte os números acima de 5 (deve haver muitas previsões erradas) - meça-os
• Classificar a matriz
• Conte os números acima de 5 (deve haver poucas previsões erradas) - meça-os

Depois de executar o código, obtive praticamente os mesmos resultados para ambas as medições.

Testado em:

1. Visual Studio 2017, lançamento (Otimização Máxima (Favorecer Velocidade) (/O2)), Windows.
2. Linux, g++ -Ofast

Então, peguei o código original da pergunta que linkei acima e ainda não obtive nenhuma melhoria para o array ordenado. Por quê? Qual é a vantagem da previsão de ramificação?

#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
#include <chrono>

int main()
{
    // Step 1: Allocate a vector of size 1 million
    std::vector<int> vec(100'000'000);

    // Step 2: Fill it with random numbers between 0 and 10
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 10);

    for (auto& val : vec)
    {
        val = dis(gen);
    }

    // Step 3: Count numbers above 5 (and measure time)
    auto start = std::chrono::high_resolution_clock::now();
    int count_above_5 = 0;
    for (size_t i = 0; i < vec.size(); i++)
    {
        if (vec[i] < 5)
        {
            ++count_above_5;
        }
    }

    auto end = std::chrono::high_resolution_clock::now();

    auto duration_before_sort = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();

    std::cout << "Count of numbers above 5 (before sorting): " << count_above_5 << std::endl;
    std::cout << "Time taken (before sorting): " << duration_before_sort << " ns" << std::endl;

    // Step 4: Sort the array
    std::sort(vec.begin(), vec.end());

    // Step 5: Count numbers above 5 in the sorted array (and measure time)

    start = std::chrono::high_resolution_clock::now();
    count_above_5 = 0;
    for (size_t i = 0; i < vec.size(); i++)
    {
        if (vec[i] < 5)
        {
            ++count_above_5;
        }
    }
    end = std::chrono::high_resolution_clock::now();


    auto duration_after_sort = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();

    std::cout << "Count of numbers above 5 (after sorting): " << count_above_5 << std::endl;
    std::cout << "Time taken (after sorting):  " << duration_after_sort << " ns" << std::endl;

    return 0;
}