Perguntas[c++](coding)

No C++ moderno é possível escrever um alias de função membro com uma sintaxe diferente desta:

class C {
   int f(int a) { return ++a; }
   inline int g(int a) { return f(a); }
};

Tentei de algumas maneiras, mas nenhuma funcionou:

class C {
   int f(int a) { return ++a; }
   const auto g1 = f;  // error: 'auto' not allowed in non-static class member
   auto& g2 = f;       // error: 'auto' not allowed in non-static class member
   using g3 = f;       // error: unknown type name 'f'
};

Por favor, não sugira usar o pré-processador...

Por que preciso disso? Porque:

• Tenho um código existente que não posso modificar e que usa a função de membro antiga, e um código novo que deve usar a nova.
• Gostaria de evitar a chamada extra (mesmo que ela possa ser otimizada).

PS: erros gerados pelo clang 20.1.0

Estou experimentando escrever uma classe leve de sinais/observadores que tem a seguinte interface (implementação removida para simplificação):

template <typename ... ARGS>
class Signal
{
public:
    void connect(AbstractSlot<ARGS...>& slot);
    void disconnect(AbstractSlot<ARGS...>& slot);
    void emit(const ARGS&...args);

    //...
};

Que é usado, por exemplo, assim:

Signal<> signal1; //A signal with no parameters
Signal<int, int> signal2; //A signal with two int parameters

signal1.emit();
signal2.emit(10, 20);

Quero poder tornar minha classe opcionalmente thread-safe. Pensei em modificar meu modelo para aceitar uma classe de "política de bloqueio" que, por padrão, é "vazia".

struct NoLock
{
    void lock() {}
    void unlock() {}
};

Na minha cabeça, eu gostaria de poder usar o modelo de sinal modificado assim:

Signal<> signal1;
Signal<std::mutex> signal1Locked;
Signal<int, int> signal2;
Signal<int, int, std::mutex> signal2Locked;

O que exigiria que eu escrevesse o modelo assim:

template <typename ... ARGS, typename LockPolicy = NoLock>
class Signal;

Exceto que isso não é C++ válido (e eu entendo o porquê; como o compilador saberia a diferença entre os argumentos policy e variadic).

Minha pergunta é: como posso alcançar o que desejo em uma sintaxe que não seja muito confusa/complexa de usar?

Meu objetivo é serializar informações usando protobuf em C++.

arquivo proto:

syntax = "proto3";

package PhoneBookSerialize;

message Date {
  int32 year = 1;
  int32 month = 2;
  int32 day = 3;
}

message Contact {
  string name = 1;
  Date birthday = 2;
  repeated string phone_number = 3;
}


message ContactList{
  repeated Contact contact = 1;
}

Código relacionado ao contato:

struct Contact {
  std::string name;
  std::optional<Date> birthday;
  std::vector<std::string> phones;

  bool operator<(const Contact& other) const {
    return name < other.name;
  }
};

class PhoneBook {
public:
  
  explicit PhoneBook(std::vector<Contact> contacts);
  void SaveTo(std::ostream& output) const;

private:
  std::vector<Contact> contact_book;

};

PhoneBook::PhoneBook(std::vector<Contact> contacts) : contact_book(contacts) {
    std::sort(contact_book.begin(), contact_book.end());
};

Função de serialização:

void PhoneBook::SaveTo(std::ostream& output) const {
    PhoneBookSerialize::ContactList contact_list;
    for(const auto& contact : contact_book){
        PhoneBookSerialize::Contact* pb_contact = contact_list.add_contact();
        pb_contact->set_name(contact.name);
        if(contact.birthday.has_value()){
            PhoneBookSerialize::Date* pb_date = pb_contact->mutable_birthday();
            pb_date->set_year(contact.birthday->year);
            pb_date->set_month(contact.birthday->month);
            pb_date->set_day(contact.birthday->day);
        }
        
        for(const auto& phone : contact.phones){
            pb_contact->add_phone_number(phone);
        }
    }

    contact_list.SerializeToOstream(&output);
};

arquivo main.cpp

#include "phone_book.h"
#include "contact.pb.h"
#include <sstream>

using namespace std;

int main(){
    const PhoneBook ab({
        {"Ab ba", Date{1980, 1, 13}, {"+79850685521"}},
        {"Ac ca", Date{1989, 4, 23}, {"+79998887766", "+71112223344"}},
        {"Ad da", Date{1989, 4, 23}, {}},
        {"No Birthday", std::nullopt, {"+7-4862-77-25-64"}},
      });
    
      ostringstream output(std::ios::binary);
      ab.SaveTo(output);
    
      istringstream input(output.str(), std::ios::binary);
    
      PhoneBookSerialize::ContactList list;
      list.ParseFromIstream(&input);
      return 0;
}

Arquivo CMakeLists.txt:

cmake_minimum_required(VERSION 3.10)
project(PhoneBookProtobuf LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Find Protocol Buffers package
find_package(Protobuf REQUIRED)

# Find Abseil package
find_package(absl REQUIRED)

include_directories(${Protobuf_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_BINARY_DIR})

# Generate protobuf files from proto directory
protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS proto/contact.proto)

# Add all source files
add_executable(main
    src/main.cpp
    src/phone_book.cpp
    src/phone_book.h
    ${PROTO_SRCS}
    ${PROTO_HDRS}
)

# Link necessary libraries
target_link_libraries(main 
    ${Protobuf_LIBRARIES}
    absl::log
    absl::log_internal_message
    absl::log_internal_check_op
)

Estou usando os seguintes comandos para criar e executar meu código:

1. Configure project:
cmake --preset default

2. Build Project:
cmake --build --preset debug

3. Run Project:
./build/main

Depois de executar o projeto, estou recebendo uma falha de segmentação no list.ParseFromIstream(&input);. Suponho que tenha algo a ver com o meu arquivo de configuração do Cmake. Também adicionei o pacote abseil à minha configuração do Cmake, porque sem ele no meu sistema operacional (macOS), o código não compila.

Mensagens de erro:

AddressSanitizer:DEADLYSIGNAL
=================================================================
==4319==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000020 (pc 0x000000000020 bp 0x7ff7b0d5f350 sp 0x7ff7b0d5f318 T0)
==4319==Hint: pc points to the zero page.
==4319==The signal is caused by a READ memory access.
==4319==Hint: address points to the zero page.
    #0 0x000000000020  (<unknown module>)
    #1 0x00010f5e6a24 in google::protobuf::internal::TcParser::FastMtR1(google::protobuf::MessageLite*, char const*, google::protobuf::internal::ParseContext*, google::protobuf::internal::TcFieldData, google::protobuf::internal::TcParseTableBase const*, unsigned long long)+0x74 (libprotobuf.29.3.0.dylib:x86_64+0xb8a24)
    #2 0x00010f63abdb in bool google::protobuf::internal::MergeFromImpl<false>(google::protobuf::io::ZeroCopyInputStream*, google::protobuf::MessageLite*, google::protobuf::internal::TcParseTableBase const*, google::protobuf::MessageLite::ParseFlags)+0xd1 (libprotobuf.29.3.0.dylib:x86_64+0x10cbdb)
    #3 0x00010f63bda2 in google::protobuf::MessageLite::ParseFromIstream(std::__1::basic_istream<char, std::__1::char_traits<char>>*)+0x32 (libprotobuf.29.3.0.dylib:x86_64+0x10dda2)
    #4 0x00010f1adbf9 in main main.cpp:23
    #5 0x7ff8165ad52f in start+0xbef (dyld:x86_64+0xfffffffffff1f52f)

==4319==Register values:
rax = 0x0000606000001700  rbx = 0x00007ff7b0d5fb20  rcx = 0x0000000000000020  rdx = 0x0000000000000000  
rdi = 0x000000010f220840  rsi = 0x0000606000001700  rbp = 0x00007ff7b0d5f350  rsp = 0x00007ff7b0d5f318  
 r8 = 0xffffffffffffffff   r9 = 0x0000000000000000  r10 = 0x00007fffffffff01  r11 = 0x00007fffffffff01  
r12 = 0x000000010f222480  r13 = 0x00007ff7b0d5f3e8  r14 = 0x0000000000000000  r15 = 0x0000000000000000  
AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV (<unknown module>) 
==4319==ABORTING
zsh: abort      ./build/main

Este código me dá erro do compilador: "esperava uma expressão".

std::array< std::string, 3 > candidates = useOutname ? { "%O.log", "%O_.log", "_%O.log" } : { "%J.log", "%J_.log", "_%J.log" };

Se mudar para uma instrução if else simples, funciona:

std::array< std::string, 3 > candidates;
if (useOutname) {
    candidates = { "%O.log", "%O_.log", "_%O.log" };
}
else {
    candidates = { "%J.log", "%J_.log", "_%J.log" };
}

Gostaria de saber por que usar o operador ternário causa erro aqui? É por causa da inicialização das chaves?

Dada uma definição de tipo de uma função, existe uma maneira de converter os parâmetros recebidos por meio de um modelo variádico como um argumento para os tipos exatos da typedeffunção ed?

#include <concepts>
#include <iostream>

typedef int foo(int, int);

template <typename func, typename... Args>
  requires std::invocable<func, Args &&...>
void bar(Args&&... args) {
  ((std::cout << std::forward<Args>(args)), ...);
}

int main() { bar<foo>(4, 4.1); }

Neste exemplo, verifico se funcwould seria invocável com os argumentos fornecidos e, em seguida, imprimo os argumentos passados. 4 e 4.1 são impressos (como esperado). Mas fooaceita int,int, então o objetivo seria imprimir 4 e 4 como resultado da conversão argspara os tipos de parâmetros aceitos por foo. Uma solução simples, porém funcional, seria muito apreciada.

É explicado como:

Ccache é um cache de compilador. Ele acelera a recompilação armazenando em cache compilações anteriores e detectando quando a mesma compilação está sendo executada novamente.

Não entendi. Quando uso um sistema de compilação como Ninja ou Makefiles e, por exemplo, altero um arquivo-fonte, o sistema de compilação já registra quais arquivos são dependências de quais unidades de tradução e evita recompilar essas unidades de tradução com base nessas informações, o que, até onde sei, eu descreveria como cache. Além disso, notei que, quando altero uma unidade de tradução, ele não apenas evita recompilar todas as unidades de tradução em arquivos-objeto novamente, mas também, de alguma forma (não sei como), evita vincular tudo novamente ao executável, de modo que, em um projeto muito grande, posso alterar o código em uma unidade de tradução, recompilar e tudo estará pronto para ser executado novamente em 2 segundos no meu rápido computador multi-core.

O que o ccache faz além disso, explique com exemplos concretos como "ele armazena em cache partes x, y, z do seu código".

Considere o seguinte cenário (comum) ao lidar com, por exemplo, OpenGL:

Você tem void glUseProgram(GLuint program);, assim como uma série de outras funções que exigem GLuint; mas não há glGetUint, você está preso a glGetInteger.

Então, digamos que você tem

class Foo() {
public:
    Foo::Foo() {
        glGetIntegerv(GL_CURRENT_PROGRAM, &program);
    }

private:
    GLuint program;
    void Bar();
};

Por literalmente mais de 10 anos em nosso projeto, tivemos um trecho de código semelhante e somente agora, sem realmente alterar a configuração, o compilador começou a reclamar sobre esta conversão específica:

error: implicit conversion changes signedness: 'GLint' (aka 'int') to 'GLuint' (aka 'unsigned int') [-Werror,-Wsign-conversion] 

A solução é obviamente simples:

class Foo() {
public:
    Foo::Foo() {
        int _program;
        glGetIntegerv(GL_CURRENT_PROGRAM, &_program);
        program = static_cast<GLuint>(_program);
    }

private:
    GLuint program;
    void Bar();
};

Mas a questão é: posso fazer a mesma coisa em apenas uma etapa, sem precisar usar um int de escopo local no meio?

O conteúdo de um arquivo de texto chamado existingfile.txté o seguinte

The First Order Derivative of X2 is
2x. The derivative of sin is cos.
Math is the best

O código abaixo é de um arquivo chamado main.cppque está no mesmo diretório que existingfile.txt O exemplo mostra o processo de

• abrindo uma alça paraexistingfile.txt
• obtendo o tamanho deexistingfile.txt
• lendo 1000 bytes deexistingfile.txt
• gerando uma matriz de caracteres de 1000 bytes até o primeiro terminador nulo

#include <windows.h>
#include <cstdio>

int main(int, char**){
//Creating Synchronous File Handle
    HANDLE hFile = CreateFileW(
        L"existingfile.txt",
        GENERIC_READ,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_ALWAYS,
        FILE_FLAG_SEQUENTIAL_SCAN,
        NULL
    );
    if (hFile == INVALID_HANDLE_VALUE) {
        printf("ERROR IN OPENING FILE %lu\n", GetLastError());
        return -1;
    }
    //Obtaining File Size
    {
        ULARGE_INTEGER FileSize;
        FileSize.LowPart = GetFileSize(hFile, &FileSize.HighPart);
        DWORD LastError = GetLastError();
        if (FileSize.LowPart == INVALID_FILE_SIZE && LastError != NO_ERROR){
            printf("FAILED TO OBTAIN FILE SIZE, ERROR %lu\n", LastError);
            return -1;
        }
        printf("FILE SIZE: %llu\n", FileSize.QuadPart);
    }
    //Reading To End Of the File
    {
        OVERLAPPED Overlapped = {};
        Overlapped.Offset = 15;
        Overlapped.OffsetHigh = 0;
        constexpr DWORD NumBytesToRead = 1000;
        char BytesRead[NumBytesToRead + 1] = {0};
        BOOL Successful = ReadFile(hFile, BytesRead, NumBytesToRead, NULL, &Overlapped);
        DWORD LastError = GetLastError();
        if (!Successful){
            if (LastError != ERROR_HANDLE_EOF){
                printf("ERROR IN OVERLAPPED SYNCHRONOUS READ TO EOF, ERROR %lu\n", LastError);
                return -1;
            }
            puts("EOF ENCOUNTERED IN OVERLAPPED SYNCHRONOUS READ TO EOF");
        }
        BytesRead[NumBytesToRead] = 0;
        printf("2: Information Read: '%s'\n", BytesRead); 
    }
    CloseHandle(hFile);
    return 0;
}

A saída que obtenho é

FILE SIZE: 88
2: Information Read: ' Derivative of X2 is
2x. The derivative of sin is cos.
Math is the best'

A saída que eu esperava era

FILE SIZE: 88
EOF ENCOUNTERED IN OVERLAPPED SYNCHRONOUS READ TO EOF
2: Information Read: ' Derivative of X2 is
2x. The derivative of sin is cos.
Math is the best'

porque está declarado na documentação do ReadFile

Considerações para trabalhar com identificadores de arquivo síncronos:

...

Se lpOverlapped não for NULL, quando uma operação de leitura síncrona atingir o final de um arquivo, ReadFile retornará FALSE e GetLastError retornará ERROR_HANDLE_EOF.

Eu ficaria muito grato se alguém pudesse explicar/descobrir a causa do porquê o comportamento esperado mencionado na documentação não está acontecendo.

É legal escrever algo assim?

#include <memory>

struct A {
    int i, j;
    constexpr A() : i((std::construct_at(&j, 2), j-1)) {}
};
constexpr A a{};
static_assert(a.i == 1);
static_assert(a.j == 2);

Aqui, io inicializador -member primeiro inicializa jo membro usando std::construct_ate depois lê seu valor em j-1.

Na prática, vejo que todos os GCC, MSVC e Clang aceitam o programa. Demonstração online: https://gcc.godbolt.org/z/YzEoPPj96

Mas Clang emite o aviso:

<source>:5:50: warning: field 'j' is uninitialized when used here [-Wuninitialized]
    5 |     constexpr A() : i((std::construct_at(&j, 2), j-1)) {}
      |                                                  ^

Isso parece contraditório, já que a leitura de valores não inicializados em expressões constantes deve resultar em falha grave. O programa está bem formado e o diagnóstico está simplesmente errado?

E graças ao @TedLyngmo, aqui está um exemplo mais complicado com alocações de heap:

#include <string>

struct A {
    std::string i, j;

    constexpr A()
        : i(((void)std::construct_at(&j,
                                     "Hello world, this is very funny indeed "
                                     "and this is a long string"),
             j + " with some exta in it"))
        , j([k=std::move(j)]()mutable { return std::move(k); }()) {}
};

static_assert( A{}.i.length() == 85 );
static_assert( A{}.j.length() == 64 );

Demonstração online: https://gcc.godbolt.org/z/zcb4hbhY3

Tenho a seguinte pergunta sobre lambdas em C++: Por que a primeira captura (em pf) por referência l-value não é permitida, mas a segunda é (pf2)?

Não estou argumentando, de uma forma ou de outra, que isso &z = z * 10deveria ser permitido; quero entender a razão técnica por trás do erro do compilador afirmando que isso não é permitido ( error: cannot capture (10 * z) by reference).

Muito obrigado antecipadamente. Esta comunidade é incrível, e peço desculpas antecipadamente se houve perguntas repetidas sobre o mesmo tópico no passado. Não consegui encontrá-las.

#include <iostream>
#include <utility>

using namespace std;

int main () {   
  int z = 10;

  // not allowed   
  auto pf = [&z = 10*z](int x) {
    ++z;
    cout << "z: " << z << endl;
    return z;   };

  // allowed   
  auto pf2 = [&z = z](int x) {
    ++z;
    cout << "z: " << z << endl;
    return z;   
  };

  cout << "pf: " << pf(20) << endl;   
  cout << "pf: " << pf(20) << endl;   
  cout << "pf2: " << pf2(20) << endl;   
  cout << "pf2: " << pf2(20) << endl;   
  return 1; 
}