Post Budowanie aplikacji Blockchain z C++ pojawił się po raz pierwszy w Coinpedia Fintech News
Wstęp
Technologia blockchain fundamentalnie przekształciła finanse i zarządzanie łańcuchem dostaw, oferując zdecentralizowane, przejrzyste i bezpieczne mechanizmy, które eliminują potrzebę korzystania z pośredników.
Dlaczego warto stworzyć aplikację blockchain?
Aplikacje blockchain zapewniają zwiększoną integralność i bezpieczeństwo danych oraz zapewniają środowisko bez zaufania do udostępniania informacji. Dzięki blockchain można wdrażać inteligentne kontrakty i tworzyć cyfrowe tokeny, które otwierają drzwi do nowych modeli ekonomicznych, takich jak zdecentralizowane finanse (DeFi) i tokenizowane aktywa itp.
W tym artykule znajdziesz krótką, 10-minutową wycieczkę do świata rozwoju technologii Blockchain za pomocą języka C++.
Podstawy Blockchain
Blockchain to cyfrowy łańcuch składający się z pojedynczych bezpiecznych i odpornych na manipulacje jednostek zwanych blokami. Każdy blok zawiera swoje metadane i wyznaczone informacje o transakcji. Do tej pory tworzyliśmy tylko pojedyncze bloki, prawda?! Jak można spróbować ustanowić połączenie między każdym blokiem w sensowny sposób? Odpowiedź brzmi: łącząc każdy blok z poprzednim blokiem za pomocą unikalnych losowych funkcji kryptograficznych znanych jako hash. Każdy blok ma swój własny hash, który jest kluczem podstawowym, a wszystkie bloki można połączyć za pomocą hashowania w kolejności chronologicznej, tworząc łańcuch, który reprezentuje całą historię transakcji w sieci.
C++ w Blockchain
C++ jest jednym z najpotężniejszych języków używanych w blockchain ze względu na swoją szybkość, elastyczność i kontrolę. Działa cuda podczas obsługi złożonych systemów, tworzenia gier i aplikacji finansowych. Bez wątpienia jest to najbardziej wszechstronny język!
C++ błyszczy w blockchain z wielu powodów. Pozwala deweloperom budować wydajne systemy blockchain dzięki zarządzaniu pamięcią niskiego poziomu, które zapewnia precyzyjną kontrolę. Wszyscy wiemy, jak ogromna i bezpieczna jest sieć Bitcoin. Wyobraź sobie, jak złożone musi być jej jądro, ponieważ musi obsługiwać niezliczone transakcje. Dlatego, aby poradzić sobie z tym zniechęcającym zadaniem, wybrano C++. Istnieje kilka znaczących aplikacji opracowanych przy użyciu C++, takich jak Bitcoin, Lifecoin, Ripple, Monero i EOS.
Dlaczego C++ jest idealnym językiem do tworzenia blockchainów?
Szybsze obliczenia
Wysoka wydajność
Efektywne zarządzanie pamięcią
Funkcje obiektowe
Obsługuje wielowątkowość
Kontrola nad zasobami systemowymi
Niezależnie od tego, czy dopiero zaczynasz przygodę z technologią blockchain, czy chcesz poszerzyć granice swoich możliwości, C++ jest dobrym wyborem do tworzenia długotrwałych aplikacji.
Zrozumienie koncepcji Blockchain w C++
Transakcje: W blockchainie transakcje są esencją, która napędza cały system. Poszczególne bloki są jak bezpieczne skarbce, które przechowują prestiżowe informacje o wymianie i wartości transakcji wraz z uczestnikami. Te transakcje są podstawowymi zapisami, które opowiadają historię tego, kto wymienił co, z kim i kiedy.
Filary Blockchain, które powinieneś znać
Decentralizacja: Decentralizacja jest powodem, dla którego blockchain wyróżnia się w całej domenie technologicznej. Czym jest decentralizacja? Jest to właściwość blockchain, dzięki której żaden pojedynczy podmiot nie sprawuje kontroli nad całą bazą danych. Dzięki temu system jest odporny na awarie i zapobiega wszelkim stronniczościom. Każde urządzenie uczestniczące (węzeł) przechowuje kopię blockchain, zapewniając przejrzystość i zapobiegając scentralizowanym awariom lub manipulacjom.
Niezmienność: Po zapisaniu danych w blockchain nie można ich zmienić bez zmiany kolejnych bloków. Odbywa się to za pomocą hashowania kryptograficznego. Stąd wszystkie zmiany wprowadzone raz nie mogą zostać cofnięte, co czyni je niezmiennymi.
Mechanizmy konsensusu: Zestaw protokołów regulujących wszystkie potrzeby blockchain. Wszystkie węzły w sieci muszą się zgodzić na metody. Mechanizmy konsensusu są używane do usprawnienia węzłów i zapewnienia, że wszystkie węzły w sieci są na tej samej stronie.
Do tej pory musiałeś zrozumieć wszystkie podstawy blockchain, prawda? Dość teorii! Zanurzmy się teraz w część praktyczną. Gotowy, aby pobrudzić sobie ręce?
W tej sekcji przeprowadzimy Cię przez cały proces tworzenia prostej aplikacji blockchain. Od konfiguracji środowiska po testowanie i wdrażanie.
1.Konfigurowanie środowiska programistycznego C++
Zanim zaczniesz rozwijać, posiadanie wszystkich warunków wstępnych jest niezbędne. W tym rozdziale przyjrzymy się, jak możesz mieć odpowiednie środowisko programistyczne.
Instalowanie kompilatora C++
Zacznijmy od wyjaśnienia, czym jest kompilator.
Kompilator jest kluczowym narzędziem w rozwoju oprogramowania, działającym jako pomost między kodem czytelnym dla człowieka, który piszesz, a kodem maszynowym, który procesor twojego komputera może zrozumieć i wykonać. W kontekście tworzenia aplikacji blockchain w C++, pierwszym krokiem jest wyposażenie się w niezawodny kompilator C++. To narzędzie przetłumaczy twój kod C++ na wykonywalny kod maszynowy, umożliwiając twojej aplikacji blockchain wydajne działanie w różnych systemach.
Dlatego, aby rozpocząć rozwój, najpierw zainstaluj kompilator C++ zgodny z Twoim systemem. Poniżej znajdują się popularne kompilatory C++, spośród których możesz wybierać:
GCC (kolekcja kompilatorów GNU):
Linux/MacOS:
Otwórz terminal i wpisz kolejno polecenia podane poniżej
a)Ubuntu/Debian:sudo apt updatesudo apt install build-essentialb)Fedora sudo dnf install gcc gcc-c++c)MacOS (narzędzia wiersza poleceń)xcode-select –install
Windows: Dla użytkowników systemu Windows projekt MinGW-w64 jest doskonałym wyborem, ponieważ stanowi port kompilatora GCC (GNU Compiler Collection) na system Windows, oferując możliwości kompilatora GCC w środowisku Windows.
Kroki instalacji:
Pobierz instalator odwiedzając oficjalną stronę MinGW-w64.
Po pobraniu uruchom instalator
Wybierz odpowiednią architekturę zgodnie ze swoimi potrzebami
Aby zakończyć, postępuj zgodnie z instrukcjami kreatora
Zaktualizuj system (jest to krok opcjonalny, ale zalecany).
Brzęk:
Linux/MacOS: sudo apt install clang (clang jest już zainstalowany w systemie MacOS) Fedora: sudo dnf install clang Windows: Clang można zainstalować za pomocą MinGW lub za pomocą instalatora projektu LLVM
MSVC (Microsoft Visual C++):
MSVC (Microsoft Visual C++) jest integralnym składnikiem Visual Studio, solidnego zintegrowanego środowiska programistycznego (IDE) opracowanego przez Microsoft. Visual Studio zapewnia kompleksowy zestaw narzędzi do tworzenia, testowania i wdrażania aplikacji, a jego instalacja automatycznie skonfiguruje MSVC w systemie.
Sprawdź instalację, korzystając z następujących poleceń w terminalu lub wierszu poleceń:
g++ –version # Dla GCCclang –version # Dla Clangcl # Dla MSVC
Wybór środowiska IDE
Zintegrowane środowisko programistyczne (IDE) zwiększa produktywność, oferując narzędzia takie jak uzupełnianie kodu, debugowanie i zarządzanie projektami w ramach ujednoliconego interfejsu. Poniżej przedstawiono kilka powszechnie używanych środowisk IDE do programowania w C++:
Visual Studio: Pobierz program Visual Studio z oficjalnej strony internetowej.
Następnie wykonaj następujące kroki zgodnie z poniższą tabelą:
CLion: Instalacja i konfiguracja:
CLion to popularne środowisko IDE oparte na technologii JetBrains. Wymaga subskrypcji, ale oferuje bezpłatne wersje próbne.
oferuje bezpłatne wersje próbne.
Visual Studio Code: Zainstaluj i skonfiguruj rozszerzenia do programowania w języku C++.
Instalowanie wymaganych bibliotek
Użyj menedżerów pakietów, aby zainstalować niezbędne biblioteki, takie jak OpenSSL dla funkcji kryptograficznych. Poniżej znajdują się kroki i różne biblioteki dla różnych systemów operacyjnych i ich polecenia.
Hurra, udało Ci się pomyślnie skonfigurować środowisko programistyczne. Teraz możesz od razu rozpocząć wykonywanie kodu w wybranym przez siebie środowisku IDE.
2. Budowanie prostego łańcucha bloków w C++
Zanim rozpoczniemy pisanie kodu, poznajmy składniki klasy blokowej.
Składniki klasy Blockclass
Indeks to liczba całkowita, która przechowuje i utrzymuje uporządkowaną kolejność bloków w porządku chronologicznym.
Znak czasu: Znak czasu przechowuje w formie ciągu znaków informację o tym, w którym momencie blok został utworzony.
Transakcje: Transakcje przechowują informacje o wymianie między uczestnikami i stan łańcucha bloków w danym momencie.
Poprzedni skrót i hash: Poprzedni skrót przechowuje kryptograficzny skrót poprzedniego bloku, natomiast skrót jest ciągiem pomieszanych lub haszowanych informacji kryptograficznych.
Nonce: Liczba całkowita używana w algorytmie konsensusu Proof of Work (PoW). Działa jak licznik, który jest zwiększany w celu znalezienia prawidłowego hasha spełniającego cel trudności. Nonce jest kluczowy dla procesu wydobywania w PoW, gdzie górnicy rywalizują o znalezienie nonce, który generuje hash z określoną liczbą wiodących zer.
Zaimplementujmy teraz wszystkie funkcje w kodzie:
klasa Block {public: int index; std::string timestamp; std::vector<Transaction> transactions; std::string previousHash; std::string hash; int nonce; // Dla PoW // Konstruktor Block(int idx, std::string time, std::vector<Transaction> txs, std::string prevHash) { index = idx; timestamp = time; transactions = txs; previousHash = prevHash; nonce = 0; hash = calculatedHash(); // Skrót bieżącego bloku } // Metoda obliczająca skrót bloku std::string calculatedHash() { std::stringstream ss; ss << index << timestamp << previousHash << nonce; // Dodaj dane transakcji i wszelkie dodatkowe szczegóły do obliczenia skrótu return sha256(ss.str()); // Symbol zastępczy dla rzeczywistej funkcji skrótu } // Metoda wydobywania bloku void mineBlock(int difficulty) { std::string target(difficulty, ‘0’); // Utwórz ciąg docelowych hashów while (hash.substr(0, challenging) != target) { nonce++; hash = calculatorHash(); } }};
Gdy skończysz definiować blockclass i jego atrybuty, możesz kontynuować i utworzyć blok genesis. Blok genesis jest pierwszym blokiem w blockchain, który musi zostać zainicjowany i ma indeks równy zero. Po zdefiniowaniu bloku genesis możesz kontynuować i dodawać nowe bloki do swojego blockchain, używając metody addblock(). Poniżej znajduje się kod:
Klasa Blockchain {public: std::vector<Block> chain; Blockchain() { chain.push_back(createGenesisBlock()); } Block createGenesisBlock() { return Block(0, „01/01/2024”, „Blok Genesis”, „0”); } Block getLatestBlock() { return chain.back(); } void addBlock(Block newBlock) { newBlock.previousHash = getLatestBlock().hash; newBlock.hash = newBlock.calculateHash(); chain.push_back(nowyBlok); }};
Utwórz i zweryfikuj transakcję. Każda transakcja ma swój własny identyfikator, predefiniowany konstruktor oraz informacje o nadawcy i odbiorcy wraz z kwotą. Po utworzeniu transakcji należy ją zweryfikować za pomocą metody validateTransaction().
class Transaction {public: std::string sender; std::string receiver; double amount; std::string transactionID; // Konstruktor Transaction(std::string snd, std::string rcp, double amt, std::string txID) { sender = snd; receiver = rcp; amount = amt; transactionID = txID; } // Metoda walidacji transakcji bool validateTransaction() { // Implementacja logiki walidacji return true; // Symbol zastępczy }};
3. Implementacja mechanizmów konsensusu w C++
Do tej pory ukończyłeś 25% procesu budowania. Teraz przejdź dalej i zaimplementuj mechanizmy konsensusu dla swojego bloku, który jest kręgosłupem całej aplikacji.
Dowód pracy
Proof of Work (PoW) to mechanizm konsensusu, w którym członkowie sieci blockchain/górnicy muszą znaleźć rozwiązanie trudnego problemu obliczeniowego, zanim będą mogli dodać nowy blok do łańcucha. Jest to zasadniczo proces znajdowania określonej liczby, zwanej nonce, która jest łączona z danymi bloku, jego hashem i innymi szczegółami w celu wygenerowania wartości hasha, która zaczyna się od określonej liczby wiodących zer. Dzięki temu proces jest wydajny i chroni sieć przed złośliwymi atakami.
W C++ możesz zaimplementować Proof of Work, dodając atrybut proof i metodę proof of work do klasy Block. Oto, jak możesz to zrobić:
#include <iostream>#include <sstream>#include <ctime>#include <string>#include <vector>#include <openssl/sha.h>używając przestrzeni nazw std;string sha256(const string str) { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, str.c_str(), str.length()); SHA256_Final(hash, &sha256); stringstream ss; for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } return ss.str();}klasa Block {publiczny: int indeks; ciąg danych; ciąg previousHash; ciąg hash; długi dowód; time_t znacznik czasu; Block(int idx, ciąg d, ciąg prevHash) { indeks = idx; dane = d; poprzedniHash = prevHash; znacznik czasu = time(nullptr); dowód = 0; hash = obliczHash(); } string obliczHash() const { stringstream ss; ss << indeks << znacznik czasu << dane << poprzedniHash << dowód; return sha256(ss.str()); } void proofOfWork(int trudność) { string cel(trudność, ‘0’); do { proof++; hash = obliczHash(); } while (hash.substr(0, trudność) != cel); }};klasa Blockchain {public: vector<Block> chain; int trudność; Blockchain(int diff) { trudność = diff; chain.emplace_back(Block(0, „Genesis Block”, „0”)); } void addBlock(string data) { Block newBlock(chain.size(), data, chain.back().hash); newBlock.proofOfWork(trudność); if (isValidProof(newBlock)) { chain.push_back(newBlock); } } bool isValidProof(const Block& block) const { return block.hash.substr(0, trudność) == string(trudność, ‘0’); }};
W powyższym fragmencie kodu możemy zobaczyć, że najpierw musimy dodać dowód i hash do bloku. Następnie określić trudność dowodu i go wydobyć. Po tym można zweryfikować dowód.
4. Tworzenie prostego interfejsu API łańcucha bloków za pomocą języka C++
API — Interfejs programowania aplikacji to narzędzie, które umożliwia różnym aplikacjom oprogramowania interakcję ze sobą. W blockchain API ułatwiają interakcję z predefiniowanymi danymi blockchain, dzięki czemu programiści mogą szybko tworzyć aplikacje bez konieczności znajomości całej podstawowej struktury sieci. API pomagają integrować blockchain z innymi platformami, takimi jak aplikacje internetowe lub mobilne. Stąd API są niezbędne, aby umożliwić efektywny rozwój i integrację.
Konfigurowanie środowiska API
Zainstaluj i skonfiguruj narzędzia wymagane do tworzenia interfejsów API w języku C++, zgodnie z poniższą tabelą:
Budowanie API
#include <cpprest/http_listener.h>#include <cpprest/json.h>#include “blockchain.h”używając przestrzeni nazw web;używając przestrzeni nazw http;używając narzędzia przestrzeni nazw;używając przestrzeni nazw http::experimental::listener;Blockchain blockchain(4); // poziom trudności 4void handleGet(http_request request) { json::value response = json::value::array(); int i = 0; for (auto& block : blockchain.chain) { json::value block_json; block_json[U(“index”)] = json::value::number(block.index); block_json[U(“data”)] = json::value::string(block.data); block_json[U(“previousHash”)] = json::value::string(block.previousHash); block_json[U(“hash”)] = json::value::string(block.hash); block_json[U(“proof”)] = json::value::number(block.proof); block_json[U(“timestamp”)] = json::value::number(block.timestamp); response[i++] = block_json; } request.reply(status_codes::OK, response);}void handlePost(http_request request) { request.extract_json().then([&](json::value requestData) { auto data = requestData[U(“data”)].as_string();blockchain.addBlock(data);request.reply(status_codes::OK, U(“Blok dodano pomyślnie”));}).wait();}int main() {http_listener listener(U(“http://localhost:8080”));listener.support(methods::GET, handleGet);listener.support(methods::POST, handlePost);try {listener.open().wait();cout << “Nasłuchiwanie na http://localhost:8080” << endl;while (prawda);} catch (wyjątek const& e) {cerr << e.what() << endl; }zwróć 0;}
handleGet pobiera cały blockchain w formacie JSON.
handlePost dodaje nowy blok do łańcucha bloków, wykorzystując dane z żądania POST.
Uruchamianie i testowanie aplikacji
Uruchamianie aplikacji
Gdy skończysz z podstawowymi funkcjonalnościami kodu zgodnie z cyklem rozwoju oprogramowania, musisz przejść do najważniejszego i nieuniknionego kroku kompilacji i testowania całej aplikacji. Jest to najważniejsze, aby potwierdzić, że komponenty w aplikacji działają zgodnie z oczekiwaniami.
Skompiluj kod: g++ -o blockchain_api blockchain_api.cpp -lboost_system -lcrypto -lssl -lcpprest Uruchom plik wykonywalny: ./blockchain_api
Powyższy kod uruchamia serwer API na http://localhost:8080.
Testowanie za pomocą Postmana
Przetestuj punkty końcowe API za pomocą narzędzia Postman lub curl:
Dodaj blok:
Metoda: POST
Adres URL: http://localhost:8080
Treść: Format JSON
{ „data”: „To jest nowy blok”}
Wyświetl Blockchain:
Metoda: GET
Adres URL: http://localhost:8080
Przykład dodania bloku i wyświetlenia łańcucha bloków za pomocą interfejsu API utworzonego w języku C++.
void handleGet(http_request request) { json::value response = json::value::array(); int i = 0; dla (auto& block : blockchain.chain) { json::value block_json; block_json[U(“index”)] = json::value::number(block.index); block_json[U(“data”)] = json::value::string(block.data); block_json[U(“previousHash”)] = json::value::string(block.previousHash); block_json[U(“hash”)] = json::value::string(block.hash); block_json[U(“proof”)] = json::value::number(block.proof); block_json[U(“timestamp”)] = json::value::number(block.timestamp); response[i++] = block_json; } request.reply(status_codes::OK, response); }void handlePost(http_request request) { request.extract_json().then([&](json::value requestData) { auto data = requestData[U(“data”)].as_string();blockchain.addBlock(data);request.reply(status_codes::OK, U(“Blok dodano pomyślnie”)) }).wait();}
Funkcja handlePost przetwarza dodawanie bloków poprzez wyodrębnienie danych z treści JSON i dodanie nowego bloku do łańcucha bloków.
Funkcja handleGet pobiera cały blockchain i odsyła go jako odpowiedź JSON.
6. Przykład budowania aplikacji Blockchain w języku C++ na żywo
Wykonanie krok po kroku
Krok 1: Utwórz klasę Block z niezbędnymi atrybutami, korzystając ze składni C++.
#include <iostream>#include <ctime>#include <string>#include <sstream>#include <vector>#include <openssl/sha.h>używając przestrzeni nazw std;klasa Blok {publiczny: int indeks; ciąg danych; ciąg poprzedniHash; ciąg hash; długi dowód; time_t znacznik czasu; Blok(int idx, const ciąg& dane, const ciąg& prevHash) : indeks(idx), dane(dane), poprzedniHash(prevHash), dowód(0), znacznik czasu(time(nullptr)) { hash = obliczHash(); } string obliczHash() const { stringstream ss; ss << indeks << znacznik czasu << dane << previousHash << dowód; return sha256(ss.str()); } void proofOfWork(int trudność) { string cel(trudność, ‘0’); do { dowód++; hash = obliczHash(); } while (hash.substr(0, trudność) != cel); }private: string sha256(const string& input) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, input.c_str(), input.size()); SHA256_Final(hash, &sha256); stringstream ss; dla (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } zwróć ss.str(); }};
Krok 2: Implementacja metody calculatorHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>class Block {publiczny: int indeks; std::string dane; std::string poprzedniHash; std::string hash; długi dowód; time_t znacznik czasu; Block(int idx, const std::string& dane, const std::string& prevHash) : indeks(idx), dane(dane), poprzedniHash(prevHash), dowód(0), znacznik czasu(time(nullptr)) { hash = obliczHash(); } std::string obliczHash() const { std::stringstream ss; ss << indeks << znacznik czasu << dane << previousHash << dowód; return sha256(ss.str()); }prywatne: std::string sha256(const std::string& input) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, input.c_str(), input.size()); SHA256_Final(hash, &sha256); std::stringstream ss; dla (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } return ss.str(); }};
Krok 3: Zdefiniuj klasę Blockchain i zainicjuj ją blokiem genesis.
klasa Blockchain {public: Blockchain(int trudność) : trudność(trudność) { łańcuch.emplace_back(Blok(0, „Blok Genesis”, „0”)); } void addBlock(const string& dane) { Blok nowyBlock(łańcuch.size(), dane, łańcuch.back().hash); newBlock.proofOfWork(trudność); łańcuch.push_back(nowyBlock); } const Blok& najnowszyBlock() const { return łańcuch.back(); } vector<Block> łańcuch;prywatny: int trudność;};
Krok 4: Implementacja metody calculatorHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>class Block {publiczny: int indeks; std::string dane; std::string poprzedniHash; std::string hash; długi dowód; time_t znacznik czasu; Block(int idx, const std::string& dane, const std::string& prevHash) : indeks(idx), dane(dane), poprzedniHash(prevHash), dowód(0), znacznik czasu(time(nullptr)) { hash = obliczHash(); } std::string obliczHash() const { std::stringstream ss; ss << indeks << znacznik czasu << dane << previousHash << dowód; return sha256(ss.str()); }prywatne: std::string sha256(const std::string& dane wejściowe) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, input.c_str(), input.size()); SHA256_Final(hash, &sha256); std::stringstream ss; for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } return ss.str(); }};
Krok 5: Zdefiniuj klasę Blockchain i zainicjuj ją blokiem genesis.
klasa Blockchain {public: Blockchain(int trudność) : trudność(trudność) { łańcuch.emplace_back(Blok(0, „Blok Genesis”, „0”)); } void addBlock(const string& dane) { Blok nowyBlock(łańcuch.size(), dane, łańcuch.back().hash); newBlock.proofOfWork(trudność); łańcuch.push_back(nowyBlock); } const Blok& najnowszyBlock() const { return łańcuch.back(); } vector<Block> łańcuch;prywatny: int trudność;};
Krok 6: Skonfiguruj środowisko API do obsługi żądań, korzystając z odpowiedniej biblioteki C++.
#include <cpprest/http_listener.h>#include <cpprest/json.h>używając przestrzeni nazw web;używając przestrzeni nazw web::http;używając przestrzeni nazw web::http::experimental::listener;klasa BlockchainAPI {publiczny: BlockchainAPI(const string& address, Blockchain& blockchain) : listener(http_listener(U(address))), blockchain(blockchain) { listener.support(methods::GET, std::bind(&BlockchainAPI::handleGet, this, std::placeholders::_1));listener.support(methods::POST, std::bind(&BlockchainAPI::handlePost, this, std::placeholders::_1));void start() {listener.open().wait(); cout << “Interfejs API łańcucha bloków uruchomiony…” << endl; }Prywatne:http_listener listener; Blockchain& blockchain;void handleGet(http_request request) {json::value response = json::value::array();int i = 0;for (const auto& block : blockchain.chain) {json::value block_json;block_json[U(“index”)] = json::value::number(block.index);block_json[U(“data”)] = json::value::string(block.data);block_json[U(“previousHash”)] = json::value::string(block.previousHash);block_json[U(“hash”)] = json::value::string(block.hash);block_json[U(“proof”)] = json::value::number(block.proof);block_json[U(“timestamp”)] = json::value::number(block.timestamp);response[i++] = block_json; } request.reply(status_codes::OK, response); }void handlePost(http_request request) {request.extract_json().then([&](json::value requestData) {string data = requestData[U(“data”)].as_string();blockchain.addBlock(data);request.reply(status_codes::OK, U(“Blok dodany pomyślnie”));}) . wait () ; }} ;
Krok 7: Przetestuj aplikację, wydobywając nowy blok i weryfikując blockchain za pomocą narzędzia Postman lub curl.
Główny:int main() { Blockchain blockchain(4); // Poziom trudności BlockchainAPI api(“http://localhost:8080”, blockchain); api.start(); return 0;}Testowanie:curl -X POST http://localhost:8080 -H “Content-Type: application/json” -d ‘{“data”:”To jest nowy blok”}’
Rozpoczęcie rozwoju technologii blockchain w języku C++ to coś więcej niż tylko pisanie kodu; chodzi o zbudowanie podstawowych elementów zdecentralizowanych systemów, które mają potencjał zrewolucjonizowania różnych branż.
Podsumowując, omówiliśmy wszystko, począwszy od podstaw programowania w języku C++ na potrzeby technologii blockchain, aż po wdrażanie i testowanie aplikacji.
Po ukończeniu tego modułu możesz dalej zgłębiać koncepcje optymalizacji, takie jak skalowalność, praktyki bezpieczeństwa, zaawansowane mechanizmy konsensusu i inteligentne kontrakty.
Pozostań ciekawy świata, podejmij wyzwanie ciągłego uczenia się i nie przestawaj kodować. Niech Twój wkład będzie siłą napędową przyszłości technologii!