使用grpc通信程序，并使用cmake进行编译

好的，以下是一个简单的 C++ gRPC 通信程序，并使用 CMake 进行编译：

首先，需要安装 gRPC 和 Protobuf。

接着，创建一个名为 `hello.proto` 的 Protobuf 文件，内容如下：

syntax = "proto3";

package helloworld;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

然后，在命令行中进入到包含 `hello.proto` 文件的目录，并执行以下命令：

$ grpc_cpp_plugin --cpp_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` hello.proto

该命令将生成 `hello.grpc.pb.h` 和 `hello.grpc.pb.cc` 文件。

接着，创建一个名为 `server.cpp` 的服务器端代码，内容如下：

#include <iostream>
#include <memory>
#include <string>

#include <grpc++/grpc++.h>
#include "hello.grpc.pb.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using helloworld::Greeter;
using helloworld::HelloRequest;
using helloworld::HelloReply;

// 实现 Greeter 服务类
class GreeterServiceImpl final : public Greeter::Service {
    Status SayHello(ServerContext* context, const HelloRequest* request,
                    HelloReply* reply) override {
        std::string prefix("Hello ");
        reply->set_message(prefix + request->name());
        return Status::OK;
    }
};

// 启动服务器
void RunServer() {
    std::string server_address("0.0.0.0:50051");
    GreeterServiceImpl service;

    // 构建服务器
    ServerBuilder builder;
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    builder.RegisterService(&service);
    std::unique_ptr<Server> server(builder.BuildAndStart());

    std::cout << "Server listening on " << server_address << std::endl;

    // 等待服务器关闭
    server->Wait();
}

int main(int argc, char** argv) {
    RunServer();
    return 0;
}

该代码将创建一个 `GreeterServiceImpl` 类，实现 `Greeter` 服务类，然后启动一个 gRPC 服务器，监听在 `0.0.0.0:50051` 地址。

接着，创建一个名为 `client.cpp` 的客户端代码，内容如下：

#include <iostream>
#include <memory>
#include <string>

#include <grpc++/grpc++.h>
#include "hello.grpc.pb.h"

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using helloworld::Greeter;
using helloworld::HelloRequest;
using helloworld::HelloReply;

class GreeterClient {
    public:
        GreeterClient(std::shared_ptr<Channel> channel)
            : stub_(Greeter::NewStub(channel)) {}

        std::string SayHello(const std::string& user) {
            HelloRequest request;
            request.set_name(user);

            HelloReply reply;

            ClientContext context;

            // 调用远程服务
            Status status = stub_->SayHello(&context, request, &reply);

            if (status.ok()) {
                return reply.message();
            } else {
                return "RPC failed";
            }
        }

    private:
        std::unique_ptr<Greeter::Stub> stub_;
};

int main(int argc, char** argv) {
    GreeterClient greeter(grpc::CreateChannel(
        "localhost:50051", grpc::InsecureChannelCredentials()));
    std::string user("world");
    std::string reply = greeter.SayHello(user);
    std::cout << "Greeter received: " << reply << std::endl;

    return 0;
}

该代码将创建一个 `GreeterClient` 类，用于调用远程服务。它将连接到 `localhost:50051` 地址，并调用 `SayHello` 方法，将 `world` 作为参数传递给远程服务。

最后，创建一个名为 `CMakeLists.txt` 的 CMake 文件，内容如下：

cmake_minimum_required(VERSION 3.0.0)

project(grpc-example VERSION 0.1.0)

set(CMAKE_CXX_STANDARD 11)

add_executable(server server.cpp hello.grpc.pb.cc hello.pb.cc)
add_executable(client client.cpp hello.grpc.pb.cc hello.pb.cc)

find_package(Protobuf REQUIRED)
find_package(gRPC REQUIRED)

target_include_directories(server PUBLIC ${Protobuf_INCLUDE_DIRS})
target_link_libraries(server ${Protobuf_LIBRARIES} gRPC::grpc++)

target_include_directories(client PUBLIC ${Protobuf_INCLUDE_DIRS})
target_link_libraries(client ${Protobuf_LIBRARIES} gRPC::grpc++)

该文件将编译 `server.cpp` 和 `client.cpp`，并链接 Protobuf 和 gRPC 库。

在命令行中进入到包含 `CMakeLists.txt` 文件的目录，并执行以下命令：

$ mkdir build
$ cd build
$ cmake ..
$ make

该命令将编译并链接代码，生成 `server` 和 `client` 可执行文件。

现在，可以在命令行中运行 `./server` 启动服务器，然后在另一个终端窗口中运行 `./client` 调用远程服务。