Daniel Yefimov's questions

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

Eu tenho a seguinte tarefa

Desenvolva uma classe chamada Tradutor que permite salvar pares de palavras bilíngues e depois traduzir palavras de um idioma para outro usando os pares já adicionados:

class Translator {
public:
  void Add(string_view source, string_view target);
  string_view TranslateForward(string_view source) const;
  string_view TranslateBackward(string_view target) const;;

private:
//
};

Mais especificamente, um objeto tdo tipo Translatordeve suportar as seguintes ações:

1. Criação usando o construtor padrão. Neste caso, a base de tradução está vazia.

2. Adicionando um par bilíngue: t.Add(source, target). Após esta chamada, assume-se que a palavra sourcena linguagem 1 corresponde à palavra targetna linguagem 2. As strings passadas para o Addmétodo podem ser destruídas antes do tobjeto.

3. Tradução da língua 1 para a língua 2: t.TranslateForward(source). Se houve uma chamada anterior t.Add(source_copy, target)para alguma string targete uma string source_copyigual source(ou sendo igual), ela deverá retornar target. Se não houvesse tal chamada, ela deveria retornar uma string vazia. Se houvesse várias dessas chamadas, ele deveria retornar targetpara a última.

4. Tradução da língua 2 para a língua 1: t.TranslateBackward(target). Se houve uma chamada anterior t.Add(source, target_copy)para alguma string sourcee uma string target_copyigual target(ou sendo igual), ela deverá retornar source. Se não houvesse tal chamada, ela deveria retornar uma string vazia. Se houvesse várias dessas chamadas, ele deveria retornar sourcepara a última.

Restrições:

• Cada string deve ser armazenada na Translatorinstância da classe no máximo uma vez. Se esta restrição for violada, você receberá um erro "Limite de memória excedido".

Basicamente, tentei a seguinte ideia simples:

#include <string_view>
#include <string>
#include <map>

using namespace std;

class Translator {
public:
    void Add(string_view source, string_view target){
        forward[source] = target;
        backward[target] = source;
    };

    string_view TranslateForward(string_view source) const{
        if(forward.count(source) == 0){
            return string_view("");
        }
        return forward.at(source);
    };

    string_view TranslateBackward(string_view target) const{
        if(backward.count(target) == 0){
            return string_view("");
        }
        return backward.at(target);

    };

private:
    map<string_view,string_view> forward;
    map<string_view,string_view> backward;
};

Eu testei com casos simples:

int main(){
    Translator translator;
    translator.Add(string("okno"), string("window"));
    translator.Add(string("stol"), string("table"));
}

E funciona bem. Mas no teste oculto eu consegui TranslateForward() returned wrong data for temporary string (Time used: 1.78/5.00, preprocess time used: 0/None, memory used: 155656192/268435456.). Parece que perdi alguns casos extremos.

Do que sinto falta (em geral também)?

Aqui está minha implementação de Merge Sort:

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>

using namespace std;


template <typename RandomIt>
void MergeSort(RandomIt range_begin, RandomIt range_end){

  int num_elements = distance(range_begin,range_end);
  if( num_elements < 2){
    return;
  }

  vector<typename RandomIt::value_type> v(range_begin, range_end);
  RandomIt mid_it = range_begin + num_elements/2;

  MergeSort(range_begin, mid_it);
  MergeSort(mid_it, range_end);

  for (int x : v) {
    cout << x << " ";
  }

  cout << endl;

  merge(begin(v), begin(v) + v.size()/2, begin(v) + v.size()/2, end(v), range_begin);


}

Suposição importante: é garantido que o comprimento do intervalo fornecido é uma potência de dois, portanto o vetor sempre pode ser dividido em duas partes iguais.

Quando executo a função int main() recebo o seguinte:

int main() {
  vector<int> v = {6, 4, 7, 6, 4, 4, 0, 1};
  MergeSort(begin(v), end(v));
  for (int x : v) {
    cout << x << " ";
  }
  cout << endl;
  return 0;
}

resultado: 4 4 0 1 6 4 7 6

A classificação não acontece e o algoritmo basicamente troca duas metades do vetor. Não consigo encontrar meu erro.