В C++ разработки существует такое обилие библиотек, что порой кажется, будто ты заблудился в дремучем лесу. И среди этого многообразия POCO (Portable Components) – как маяк для тех, кто ищет надёжное, производительное и, что немаловажно, кроссплатформенное решение. Основанная Гюнтером Обильчнигом в 2004 году, эта библиотека с годами превратилась из маленького побочного проекта в полноценный набор инструментов, которым пользуются тысячи разработчиков.
Создание каркаса современного приложения с POCO
POCO – это целая система, которая продумана до мелочей. Её идейный стержень – мост через пропасть между низкоуровневыми системными API и высокоуровневыми абстракциями, необходимыми для быстрой разработки. Вспоминаю, как однажды в рамках трёхдневного хакатона мы с командой создали многопоточный сервер для обработки финансовых данных – и основой был именно POCO, который взял на себя всю "грязную" работу по управлению сокетами, потоками и парсингу JSON. Ключевая сила POCO – его модульность. Вместо одной гигантской "всё-в-одном" библиотеки мы имеем несколько слоёв, которые можно использовать по отдельности. Центром этой "солнечной системы" выступает POCO Foundation – ядро, в котором сконцентрированы базовые классы для работы со строками, потоками, временем, а также основные шаблоны проектирования и абстракции потоков ввода-вывода.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| #include <Poco/DateTime.h>
#include <Poco/DateTimeFormatter.h>
#include <iostream>
int main() {
Poco::DateTime now;
std::string formatted = Poco::DateTimeFormatter::format(
now, "%Y-%m-%d %H:%M:%S.%i");
std::cout << "Точное время: " << formatted << std::endl;
// Расчёт времени через неделю
Poco::DateTime nextWeek(now);
nextWeek += Poco::Timespan(7 * Poco::Timespan::DAYS);
std::cout << "Через неделю: "
<< Poco::DateTimeFormatter::format(nextWeek, "%Y-%m-%d")
<< std::endl;
return 0;
} |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| #include <Poco/Data/Session.h>
#include <Poco/Data/SQLite/Connector.h>
#include <vector>
#include <iostream>
using namespace Poco::Data::Keywords;
using Poco::Data::Session;
using Poco::Data::Statement;
struct Person {
int id;
std::string name;
int age;
};
int main() {
// Инициализация коннектора
Poco::Data::SQLite::Connector::registerConnector();
// Создание сессии
Session session("SQLite", "data.db");
// Создание таблицы
session << "DROP TABLE IF EXISTS Person", now;
session << "CREATE TABLE Person (id INTEGER PRIMARY KEY, name VARCHAR, age INTEGER)", now;
// Вставка данных
Person person = {0, "Алексей", 33};
session << "INSERT INTO Person VALUES(?, ?, ?)",
use(person.id), use(person.name), use(person.age), now;
// Чтение данных
std::vector<Person> people;
Person result;
Statement select(session);
select << "SELECT id, name, age FROM Person",
into(result.id), into(result.name), into(result.age),
range(0, 1);
while (!select.done()) {
select.execute();
people.push_back(result);
}
// Вывод результатов
for (const auto& p : people) {
std::cout << p.id << ": " << p.name << ", " << p.age << std::endl;
}
return 0;
} |
|
Я долгое время работал над проектом аналитической платформы, где нам требовалось обрабатывать терабайты данных в реальном времени. Мы использывали POCO для создания HTTP и WebSocket серверов, которые обслуживали тысячи одновременных подключений с минимальным потреблением ресурсов. POCO Foundation с его классами Thread, ThreadPool и Task позволил в разы сократить время на создание прототипа многопоточной обработки. Особенно стоит отметить возможности POCO для прототипирвания. Представьте, что вы можете набросать полноценный HTTP-сервер буквально за 20-30 строк кода:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| #include <Poco/Net/HTTPServer.h>
#include <Poco/Net/HTTPRequestHandler.h>
#include <Poco/Net/HTTPServerRequest.h>
#include <Poco/Net/HTTPServerResponse.h>
#include <Poco/Net/ServerSocket.h>
#include <Poco/Util/ServerApplication.h>
#include <iostream>
class HelloHandler : public Poco::Net::HTTPRequestHandler {
public:
void handleRequest(Poco::Net::HTTPServerRequest& request,
Poco::Net::HTTPServerResponse& response) override {
response.setStatus(Poco::Net::HTTPResponse::HTTP_OK);
response.setContentType("text/html");
std::ostream& responseStream = response.send();
responseStream << "<html><body>";
responseStream << "<h1>Привет, мир!</h1>";
responseStream << "<p>Ваш запрос: " << request.getURI() << "</p>";
responseStream << "</body></html>";
}
};
class RequestHandlerFactory : public Poco::Net::HTTPRequestHandlerFactory {
public:
Poco::Net::HTTPRequestHandler* createRequestHandler(
const Poco::Net::HTTPServerRequest&) override {
return new HelloHandler;
}
};
class WebServerApp : public Poco::Util::ServerApplication {
protected:
int main(const std::vector<std::string>&) override {
Poco::Net::ServerSocket socket(8080);
Poco::Net::HTTPServer server(
new RequestHandlerFactory, socket, new Poco::Net::HTTPServerParams);
server.start();
std::cout << "Сервер запущен на порту 8080" << std::endl;
waitForTerminationRequest();
std::cout << "Остановка сервера..." << std::endl;
server.stop();
return Application::EXIT_OK;
}
};
POCO_SERVER_MAIN(WebServerApp) |
|
При работе с данными в крупных проектах приходится серьёзно задумываться о эффективном управлении памятью. POCO Data предоставляет несколько подходов к оптимизации, которые самым потрясающим образом могут превратить "еле ползущее" приложение в шуструю систему. Один из малоизвестных, но кртически важных приемов — использование объектного пула (object pool) для подключений к базе данных. В высоконагруженных системах создание и закрытие соединений с БД может стать настоящим узким горлышком. POCO решает эту проблему:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| #include <Poco/Data/SessionPool.h>
#include <Poco/Data/Session.h>
using namespace Poco::Data;
int main() {
// Инициализация пула подключений
SessionPool pool("SQLite", "database.db", 1, 10, 20);
// Получение сессии из пула
Session session = pool.get();
// Работа с сессией...
session << "CREATE TABLE IF NOT EXISTS messages (id INTEGER, text VARCHAR)", now;
// Сессия автоматически вернется в пул при уничтожении
// Реальное соединение с БД остается открытым для повторного использования
return 0;
} |
|
Ещё одно мощное свойство POCO — встроенная поддержка JSON. В нынешнем мире веб-сервисов и REST API это жизненно необходимый компонент. POCO предлагает интуитивный API для работы с JSON, который легко стыкуется с объектами предметной области:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| #include <Poco/JSON/Parser.h>
#include <Poco/JSON/PrintHandler.h>
#include <Poco/JSON/Object.h>
#include <iostream>
struct User {
std::string name;
int age;
bool active;
Poco::JSON::Object::Ptr toJSON() const {
Poco::JSON::Object::Ptr json = new Poco::JSON::Object();
json->set("name", name);
json->set("age", age);
json->set("active", active);
return json;
}
static User fromJSON(const Poco::JSON::Object::Ptr& json) {
User user;
user.name = json->getValue<std::string>("name");
user.age = json->getValue<int>("age");
user.active = json->getValue<bool>("active");
return user;
}
};
int main() {
// Создание пользователя и сериализация в JSON
User user{"Мария", 28, true};
auto jsonObj = user.toJSON();
std::stringstream ss;
jsonObj->stringify(ss);
std::cout << "JSON: " << ss.str() << std::endl;
// Парсинг JSON
Poco::JSON::Parser parser;
auto result = parser.parse(ss.str());
auto parsedObj = result.extract<Poco::JSON::Object::Ptr>();
User newUser = User::fromJSON(parsedObj);
std::cout << "Имя: " << newUser.name << ", Возраст: " << newUser.age << std::endl;
return 0;
} |
|
Не могу не упомянуть и про систему логирования в POCO. Это настоящая жемчужина для отладки сложных систем. Конфигурируемая, потокобезопасная и поддерживающая множество "приемников" (консоль, файл, сокет, база данных), система логирования POCO невероятно гибка:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| #include <Poco/Logger.h>
#include <Poco/FileChannel.h>
#include <Poco/PatternFormatter.h>
#include <Poco/FormattingChannel.h>
#include <Poco/AutoPtr.h>
int main() {
// Настройка канала вывода в файл
Poco::AutoPtr<Poco::FileChannel> fileChannel(new Poco::FileChannel("application.log"));
fileChannel->setProperty("rotation", "10 M"); // Ротация логов при достижении 10 МБ
// Настройка форматирования
Poco::AutoPtr<Poco::PatternFormatter> formatter(new Poco::PatternFormatter);
formatter->setProperty("pattern", "%Y-%m-%d %H:%M:%S [%p] [%s]: %t");
// Объединение канала и форматировщика
Poco::AutoPtr<Poco::FormattingChannel> formattingChannel(
new Poco::FormattingChannel(formatter, fileChannel));
// Получение и настройка логгера
Poco::Logger& logger = Poco::Logger::get("AppLogger");
logger.setChannel(formattingChannel);
// Логирование
logger.information("Приложение запущено");
logger.warning("Внимание! Обнаружена потенциальная проблема");
logger.error("Произошла ошибка: %s", "Диск заполнен");
return 0;
} |
|
Библиотеки классов Poco, Loki
Есть библиотеки классов С++ такие как:
Poco
Loki
Поставляются "производителями" только в... Установка библиотеки Poco
Помогите решить проблему с установкой библиотеки poco. У меня VS 2017, win x64. Запускаю... Стоит ли дополнять код библиотеки или можно обходиться наследованием? Poco PropertyFileConfiguration
Всем привет.
Я использую Poco::Util::PropertyFileConfiguration , с помощью этого класса можно... memory leak или "ОС подчистит" (Знакомство с Modern C++ Design\Loki Александреску приветствуется)
Доброго времени суток, уважаемые.
Возможно мой вопрос покажется вам несколько странным, однако...
Асинхронное программирование с ACE
После знакомства с POCO самое время погрузиться в мир ACE (Adaptive Communication Environment) — настоящего исполина среди C++ библиотек. Если POCO можно сравнить с швейцарским ножом, то ACE — это целый набор промышленных инструментов. Созданный Дугласом Шмидтом в начале 90-х годов в Вашингтонском университете, ACE прошёл огонь, воду и медные трубы — от телекоммуникационных систем до аэрокосмических приложений.
Первое, что бросается в глаза при работе с ACE — его масштаб. Библиотека насчитывает более полумиллиона строк кода и реализует десятки паттернов проектирования. Однако истинная красота ACE раскрывается при создании асинхронных сетевых приложений. Именно здесь, в мире неблокирующего ввода-вывода и событийно-ориентированного программирования, ACE чувствует себя как рыба в воде.
Основа ACE — паттерн Реактор (Reactor), который кардинально меняет подход к обработке событий. Вместо того чтобы создавать отдельный поток для каждого соединения (что чревато исчерпанием ресурсов при тысячах подключений), Реактор демультиплексирует события и отправляет их в соответствующие обработчики.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
| #include <ace/Reactor.h>
#include <ace/SOCK_Acceptor.h>
#include <ace/SOCK_Stream.h>
#include <iostream>
class EchoHandler : public ACE_Event_Handler {
private:
ACE_SOCK_Stream stream_;
public:
EchoHandler(ACE_HANDLE handle) {
stream_.set_handle(handle);
}
// Этот метод вызывается, когда на сокете есть данные для чтения
virtual int handle_input(ACE_HANDLE) override {
char buffer[1024];
ssize_t bytes_read = stream_.recv(buffer, sizeof(buffer) - 1);
if (bytes_read > 0) {
buffer[bytes_read] = '\0';
std::cout << "Получено: " << buffer << std::endl;
// Эхо-ответ клиенту
stream_.send(buffer, bytes_read);
return 0;
}
// Соединение закрыто или произошла ошибка
return -1;
}
// Метод для получения дескриптора
virtual ACE_HANDLE get_handle() const override {
return stream_.get_handle();
}
// Вызывается при ошибке или закрытии соединения
virtual int handle_close(ACE_HANDLE, ACE_Reactor_Mask mask) override {
stream_.close();
delete this;
return 0;
}
};
class AcceptHandler : public ACE_Event_Handler {
private:
ACE_SOCK_Acceptor acceptor_;
public:
AcceptHandler(u_short port) {
ACE_INET_Addr addr(port);
acceptor_.open(addr);
}
virtual ACE_HANDLE get_handle() const override {
return acceptor_.get_handle();
}
// Вызывается, когда приходит новое соединение
virtual int handle_input(ACE_HANDLE) override {
ACE_SOCK_Stream stream;
if (acceptor_.accept(stream) == -1) {
return -1;
}
EchoHandler* handler = new EchoHandler(stream.get_handle());
ACE_Reactor::instance()->register_handler(
handler, ACE_Event_Handler::READ_MASK);
return 0;
}
};
int main() {
AcceptHandler acceptor(8080);
// Регистрируем акцептор в реакторе
ACE_Reactor::instance()->register_handler(
&acceptor, ACE_Event_Handler::READ_MASK);
std::cout << "Эхо-сервер запущен на порту 8080" << std::endl;
// Запуск цикла обработки событий
ACE_Reactor::instance()->run_reactor_event_loop();
return 0;
} |
|
run_reactor_event_loop() — этот метод блокирует выполнение в ожидании событий, а когда события происходят, вызывает соответствующие обработчики. И что важно — всё это в одном потоке! Я помню, как на заре своей карьеры пытался написать чат-сервер, способный обслуживать сотни клиентов. Наивный подход с созданием потока для каждого клиента привёл к катастрофическому расходу памяти и падению производительности уже при нескольких десятках подключений. Переход на ACE с его Реактором позволил обслуживать более 1000 одновременных соединений без заметного увеличения потребления ресурсов.
Однако Реактор — это лишь одна сторона медали. ACE также предлагает паттерн Проактор (Proactor), предназначенный для асинхронных операций ввода-вывода. В отличие от Реактора, который уведомляет о возможности выполнения операции, Проактор инициирует асинхронную операцию и уведомляет о её завершении.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| #include <ace/Proactor.h>
#include <ace/Asynch_IO.h>
#include <ace/SOCK_Stream.h>
#include <ace/SOCK_Connector.h>
#include <iostream>
class ClientHandler : public ACE_Service_Handler {
private:
ACE_SOCK_Stream stream_;
char buffer_[1024];
public:
// Вызывается после установки соединения
virtual void open(ACE_HANDLE handle, ACE_Message_Block&) override {
this->handle(handle);
// Инициируем асинхронное чтение
ACE_Asynch_Read_Stream reader;
reader.open(*this);
ACE_Message_Block* mb = new ACE_Message_Block(1024);
reader.read(*mb, mb->size());
}
// Вызывается после завершения чтения
virtual void handle_read_stream(const ACE_Asynch_Read_Stream::Result& result) override {
if (!result.success() || result.bytes_transferred() == 0) {
delete this;
return;
}
ACE_Message_Block& mb = result.message_block();
mb.rd_ptr()[result.bytes_transferred()] = '\0';
std::cout << "Получено от сервера: " << mb.rd_ptr() << std::endl;
// Инициируем следующее чтение
ACE_Asynch_Read_Stream reader;
reader.open(*this);
mb.reset();
reader.read(mb, mb.size());
}
};
int main() {
// Инициализация Proactor
ACE_Proactor::instance()->open();
// Создание асинхронного коннектора
ACE_Asynch_Connector<ClientHandler> connector;
connector.open();
// Подключение к серверу
ACE_INET_Addr server_addr("localhost", 8080);
connector.connect(server_addr);
std::cout << "Подключение к серверу..." << std::endl;
// Запуск цикла обработки событий
ACE_Proactor::instance()->proactor_run_event_loop();
return 0;
} |
|
Тонкая настройка ACE Proactor для достижения максимальной производительности — целое искусство. Первое, что стоит сделать — это настроить размер пула потоков:
| C++ | 1
2
3
4
5
6
7
8
9
| // Настройка пула потоков для Proactor
ACE_TP_Reactor tp_reactor;
ACE_Proactor proactor(&tp_reactor);
// Создание группы потоков
ACE_Thread_Manager* thread_manager = ACE_Thread_Manager::instance();
thread_manager->spawn_n(8, // Оптимально число потоков ~ 2 * количество ядер CPU
(ACE_THR_FUNC)ACE_Proactor::run_event_loop,
&proactor); |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
| // Создание пула буферов для асинхронного ввода-вывода
ACE_Message_Block_Data_Pool data_pool(1024, // Размер блока
1024, // Количество блоков
ACE_Message_Block_Data_Pool::MB_PREALLOCATE);
// Использование пула при создании сообщения
ACE_Message_Block* mb = new ACE_Message_Block(1024,
ACE_Message_Block::MB_DATA,
0,
0,
&data_pool); |
|
Встроенная поддержка систем реального времени делает ACE незаменимым для разработки приложений с жесткими ограничениями по времени. Представьте систему управления промышленным роботом, где задержка реакции даже в несколько миллисекунд может привести к серьёзным последствиям. ACE обладает средствами для тайм-аутов, контроля приоритетов и планирования задач, которые обеспечивают предсказуемость работы системы.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
| #include <ace/Task.h>
#include <ace/Thread_Manager.h>
#include <ace/OS_NS_time.h>
#include <iostream>
class RealTimeTask : public ACE_Task<ACE_MT_SYNCH> {
public:
int svc() override {
// Установка высокого приоритета для потока
ACE_Thread::set_priority(
ACE_Thread::self(),
ACE_Sched_Params::priority_max(ACE_SCHED_FIFO)
);
ACE_Time_Value interval(0, 10000); // 10 милисекунд
ACE_Time_Value next_wake_time = ACE_OS::gettimeofday();
for (int i = 0; i < 1000; ++i) {
// Вычисление следующего времени пробуждения
next_wake_time += interval;
// Какая-то критически важная работа
processCriticalData();
// Сон до следующего запланированного времени
ACE_Time_Value current_time = ACE_OS::gettimeofday();
if (next_wake_time > current_time) {
ACE_OS::sleep(next_wake_time - current_time);
} else {
// Не успели уложиться в интервал!
std::cout << "Предупреждение: цикл выполняется дольше интервала!" << std::endl;
next_wake_time = ACE_OS::gettimeofday() + interval;
}
}
return 0;
}
private:
void processCriticalData() {
// Имитация работы
ACE_OS::sleep(ACE_Time_Value(0, 5000)); // 5 миллисекунд работы
}
};
int main() {
RealTimeTask rt_task;
rt_task.activate();
ACE_Thread_Manager::instance()->wait();
return 0;
} |
|
Одно из наиболее мощных свойств ACE — богатая коллекция реализованных паттернов проектирования. Фактически, ACE можно рассматривать как практическое воплощение книги "Паттерны проектирования" в контексте сетевого и распределённого программирования. Вот лишь несколько из них:
Acceptor-Connector — паттерн для разделения установления соединения и обработки данных. Это позволяет разрабатывать код, не привязанный к конкретному типу соединения (TCP, UDP, локальные сокеты и т.д.).
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| #include <ace/Acceptor.h>
#include <ace/SOCK_Acceptor.h>
#include <ace/Svc_Handler.h>
#include <iostream>
// Обработчик соединения
class EchoHandler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> {
public:
int open(void*) override {
return this->reactor()->register_handler(
this, ACE_Event_Handler::READ_MASK);
}
int handle_input(ACE_HANDLE) override {
char buffer[128];
ssize_t recv_cnt = this->peer().recv(buffer, sizeof(buffer) - 1);
if (recv_cnt > 0) {
buffer[recv_cnt] = '\0';
std::cout << "Получено: " << buffer << std::endl;
// Отправка эхо
this->peer().send(buffer, recv_cnt);
return 0;
}
return -1; // Ошибка или закрытие соединения
}
};
// Определение типа акцептора на основе шаблона
typedef ACE_Acceptor<EchoHandler, ACE_SOCK_ACCEPTOR> EchoAcceptor;
int main() {
// Инициализация акцептора на порту 8080
EchoAcceptor acceptor;
ACE_INET_Addr listen_addr(8080);
acceptor.open(listen_addr);
// Запуск цикла обработки событий
ACE_Reactor::instance()->run_reactor_event_loop();
return 0;
} |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
| #include <ace/Activation_Queue.h>
#include <ace/Method_Request.h>
#include <ace/Task.h>
#include <ace/Future.h>
#include <iostream>
// Определение метода-запроса для вычисления факториала
class FactorialRequest : public ACE_Method_Request {
private:
int n_;
ACE_Future<int> result_;
public:
FactorialRequest(int n, ACE_Future<int> result)
: n_(n), result_(result) {}
int call() override {
int factorial = 1;
for (int i = 2; i <= n_; ++i) {
factorial *= i;
}
result_.set(factorial);
return 0;
}
};
// Определение активного объекта-обслуживателя
class MathService : public ACE_Task<ACE_MT_SYNCH> {
private:
ACE_Activation_Queue activation_queue_;
public:
int svc() override {
while (1) {
// Ожидание следующего запроса из очереди
auto request = activation_queue_.dequeue();
if (!request) break;
// Выполнение запроса
request->call();
delete request;
}
return 0;
}
ACE_Future<int> factorial(int n) {
ACE_Future<int> result;
activation_queue_.enqueue(new FactorialRequest(n, result));
return result;
}
// Запуск потока обработки
void start() {
this->activate();
}
};
int main() {
MathService math_service;
math_service.start();
// Асинхронный вызов вычисления факториала
ACE_Future<int> result5 = math_service.factorial(5);
ACE_Future<int> result10 = math_service.factorial(10);
// Получение результатов
int value5, value10;
result5.get(value5);
result10.get(value10);
std::cout << "5! = " << value5 << std::endl;
std::cout << "10! = " << value10 << std::endl;
return 0;
} |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
| #include <ace/Thread_Mutex.h>
#include <ace/Condition_Thread_Mutex.h>
#include <iostream>
#include <queue>
// Потокобезопасная очередь с использованием паттерна Monitor Object
template <typename T>
class SafeQueue {
private:
std::queue<T> queue_;
ACE_Thread_Mutex mutex_;
ACE_Condition_Thread_Mutex not_empty_;
public:
SafeQueue() : not_empty_(mutex_) {}
void enqueue(const T& item) {
ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
queue_.push(item);
// Сигнал о том, что очередь не пуста
not_empty_.signal();
}
T dequeue() {
ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
// Ожидание, пока очередь не станет непустой
while (queue_.empty()) {
not_empty_.wait();
}
T item = queue_.front();
queue_.pop();
return item;
}
bool isEmpty() {
ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
return queue_.empty();
}
};
// Пример использования
int main() {
SafeQueue<std::string> messageQueue;
// Один поток добавляет элементы
ACE_Thread producer;
ACE_Thread::spawn(
[](void* arg) -> ACE_THR_FUNC_RETURN {
auto queue = static_cast<SafeQueue<std::string>*>(arg);
for (int i = 0; i < 10; ++i) {
std::string message = "Сообщение #" + std::to_string(i);
queue->enqueue(message);
ACE_OS::sleep(1);
}
return 0;
},
&messageQueue,
THR_NEW_LWP | THR_DETACHED
);
// Другой поток извлекает элементы
for (int i = 0; i < 10; ++i) {
std::string message = messageQueue.dequeue();
std::cout << "Получено: " << message << std::endl;
}
return 0;
} |
|
Паттерны в ACE — не просто абстрактные концепции, а хорошо оптимизированные, проверенные временем конструкции. Я наблюдал, как опытный архитектор системы управления мобильной сетью заменил самописную реализацию распределённых компонентов на стандартные решения из ACE. В результате код сократился на 40%, а количество аварийных ситуаций уменьшилось в пять раз. Вот ещё один интересный паттерн, реализованный в ACE — Half-Sync/Half-Async. Этот паттерн разделяет систему на синхронную и асинхронную части, соединенные очередью. Асинхронная часть получает запросы и помещает их в очередь, синхронная же извлекает и обрабатывает их.
Метапрограммирование с Loki
Если POCO и ACE можно назвать промышленными бульдозерами C++ индустрии, то Loki больше похож на ювелирные инструменты мастера-часовщика. Эта библиотека, созданная Андреем Александреску как практическое дополнение к его революционной книге "Modern C++ Design", перевернула представление многих разработчиков о том, на что способен C++ в области обобщённого программирования и метапрограммирования на основе шаблонов.
Loki – это целая философия, набор техник и полигон для экспериментов с возможностями C++ на этапе компиляции. В отличие от POCO и ACE, Loki не ставит своей целью решение конкретных прикладных задач вроде сетевого взаимодействия или обработки данных. Вместо этого, Loki предлагает набор гибких конструкций для создания высокоуровневых абстракций с нулевой или минимальной потерей производительности. Ключевой концепцией Loki является так называемый "основаный на политиках дизайн" (policy-based design). Этот подход предлагает создавать компоненты из небольших, независимых и взаимозаменяемых политик, каждая из которых отвечает за отдельный аспект поведения компонента. Вспоминается классическая аналогия с конструктором LEGO – из простых деталек можно собрать практически любую конструкцию.
Рассмотрим пример реализации Singleton с использованием Loki:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| #include <loki/Singleton.h>
#include <iostream>
// Класс, который мы хотим сделать синглтоном
class DatabaseConnection {
public:
void connect() {
std::cout << "Подключение к базе данных..." << std::endl;
}
void query(const std::string& sql) {
std::cout << "Выполнение запроса: " << sql << std::endl;
}
};
// Определение синглтона с использованием политик
typedef Loki::SingletonHolder<
DatabaseConnection, // Класс, который нужно сделать синглтоном
Loki::CreateUsingNew, // Политика создания (через new)
Loki::DefaultLifetime, // Политика времени жизни (до конца программы)
Loki::SingleThreaded // Политика потокобезопасности
> DBConnectionSingleton;
int main() {
// Получение экземпляра синглтона и использование
DBConnectionSingleton::Instance().connect();
DBConnectionSingleton::Instance().query("SELECT * FROM users");
return 0;
} |
|
DatabaseConnection с помощью SingletonHolder из Loki. Обратите внимание на политики, которые мы указали: политика создания, политика времени жизни и политика потокобезопасности. Изменяя эти политики, мы можем тонко настраивать поведение синглтона без изменения основного кода.
Одной из самых впечатляющих возможностей Loki является работа с типами данных как с объектами первого класса. В C++ получить информацию о типе во время компиляции традиционно было сложно. Loki предлагает целый набор инструментов для анализа и манипуляции типами. Центральной конструкцией здесь выступают типовые списки (TypeList). Это рекурсивная структура, которая позволяет хранить и обрабатывать произвольное количество типов:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| #include <loki/TypeList.h>
#include <iostream>
#include <string>
#include <typeinfo>
// Определение списка типов
typedef Loki::TypeList<int,
Loki::TypeList<float,
Loki::TypeList<std::string,
Loki::NullType>>> MyTypes;
// Шаблон для вычисления размера типа в списке по индексу
template <class TList, unsigned int index>
struct SizeOfTypeAt {
enum { value = sizeof(Loki::TypeAt<TList, index>::Result) };
};
int main() {
// Получение информации о типах в списке
std::cout << "Количество типов: " << Loki::Length<MyTypes>::value << std::endl;
std::cout << "Тип #0: " << typeid(Loki::TypeAt<MyTypes, 0>::Result).name()
<< ", размер: " << SizeOfTypeAt<MyTypes, 0>::value << std::endl;
std::cout << "Тип #1: " << typeid(Loki::TypeAt<MyTypes, 1>::Result).name()
<< ", размер: " << SizeOfTypeAt<MyTypes, 1>::value << std::endl;
std::cout << "Тип #2: " << typeid(Loki::TypeAt<MyTypes, 2>::Result).name()
<< ", размер: " << SizeOfTypeAt<MyTypes, 2>::value << std::endl;
// Проверка наличия типа в списке
std::cout << "Содержит double? "
<< Loki::IndexOf<MyTypes, double>::value << std::endl;
std::cout << "Содержит std::string? "
<< Loki::IndexOf<MyTypes, std::string>::value << std::endl;
return 0;
} |
|
Лично для меня одной из наиболее полезных фич Loki стали фабрики. Паттерн Фабрика позволяет создавать объекты, не раскрывая логики их создания, и Loki предлагает несколько гибких реализаций.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
| #include <loki/Factory.h>
#include <iostream>
#include <memory>
#include <string>
// Базовый класс
class Enemy {
public:
virtual void attack() = 0;
virtual ~Enemy() {}
};
// Конкретные классы
class Orc : public Enemy {
public:
void attack() override {
std::cout << "Орк наносит удар топором!" << std::endl;
}
};
class Dragon : public Enemy {
public:
void attack() override {
std::cout << "Дракон выдыхает пламя!" << std::endl;
}
};
class Goblin : public Enemy {
public:
void attack() override {
std::cout << "Гоблин стреляет из лука!" << std::endl;
}
};
// Определение фабрики
typedef Loki::Factory<Enemy, std::string> EnemyFactory;
int main() {
// Регистрация конструкторов
EnemyFactory factory;
factory.Register("orc", []() { return new Orc(); });
factory.Register("dragon", []() { return new Dragon(); });
factory.Register("goblin", []() { return new Goblin(); });
// Создание объектов через фабрику
std::unique_ptr<Enemy> enemy1(factory.CreateObject("orc"));
std::unique_ptr<Enemy> enemy2(factory.CreateObject("dragon"));
if (enemy1) enemy1->attack();
if (enemy2) enemy2->attack();
// Попытка создать незарегистрированный тип
std::unique_ptr<Enemy> enemy3(factory.CreateObject("troll"));
if (!enemy3) {
std::cout << "Тип 'troll' не зарегистрирован в фабрике!" << std::endl;
}
return 0;
} |
|
Еще одна потрясающая возможность Loki — умные указатели. Задолго до появления std::shared_ptr и std::unique_ptr в стандартной библиотеке, Loki предлагал свою реализацию умных указателей с гибкой настройкой поведения:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| #include <loki/SmartPtr.h>
#include <iostream>
class Resource {
public:
Resource() {
std::cout << "Resource созданн" << std::endl;
}
~Resource() {
std::cout << "Resource уничтожен" << std::endl;
}
void use() {
std::cout << "Resource используется" << std::endl;
}
};
int main() {
// Умный указатель с подсчётом ссылок
typedef Loki::SmartPtr<Resource, Loki::RefCounted> ResourcePtr;
{
ResourcePtr ptr1(new Resource());
ptr1->use();
{
ResourcePtr ptr2 = ptr1; // Увеличение счётчика ссылок
ptr2->use();
// Здесь ptr2 уничтожается, но объект живёт
}
ptr1->use();
// Здесь ptr1 уничтожается, и сам Resource тоже
}
return 0;
} |
|
Одной из наиболее впечатляющих возможностей Loki является генерирование кода во время компиляции. Вместо того чтобы писать однотипный код для разных типов данных, мы можем использовать шаблоны для создания обобщенных решений. Вспоминаю проект обработки финансовых транзакций, где нам нужно было обрабатывать десятки различных типов операций с почти идентичной логикой. Вместо копипасты мы применили подход, основаный на метапрограммировании:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| #include <loki/Typelist.h>
#include <iostream>
#include <string>
// Определение типов транзакций
struct Deposit { static std::string name() { return "Пополнение"; } };
struct Withdrawal { static std::string name() { return "Снятие"; } };
struct Transfer { static std::string name() { return "Перевод"; } };
// Список типов для обработки
typedef LOKI_TYPELIST_3(Deposit, Withdrawal, Transfer) TransactionTypes;
// Обработчик для конкретного типа
template <typename T>
struct TransactionProcessor {
static void process() {
std::cout << "Обработка транзакции типа: " << T::name() << std::endl;
// Реальная логика обработки...
}
};
// Генерический обработчик для списка типов
template <class TList> struct ProcessTransactions;
// Специализация для последнего элемента списка
template <class T>
struct ProcessTransactions<Loki::Typelist<T, Loki::NullType>> {
static void execute() {
TransactionProcessor<T>::process();
}
};
// Рекурсивная специализация
template <class Head, class Tail>
struct ProcessTransactions<Loki::Typelist<Head, Tail>> {
static void execute() {
TransactionProcessor<Head>::process();
ProcessTransactions<Tail>::execute();
}
};
int main() {
// Запуск обработки для всех типов
ProcessTransactions<TransactionTypes>::execute();
return 0;
} |
|
Другой мощный инструмет Loki — механизм многометодов (Multimethods). В C++ метод выбирается в зависимости от типа объекта, для которого он вызывается, но не от типов аргументов. Многометоды позволяют перегружать функции в зависимости от динамических типов аргументов:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| #include <loki/MultiMethods.h>
#include <iostream>
// Иерархия фигур
class Shape {
public:
virtual ~Shape() {}
};
class Circle : public Shape {};
class Square : public Shape {};
// Определение мультиметода для проверки коллизий
struct CollisionDetector {
// Коллизия круг-круг
static void collide(Circle&, Circle&) {
std::cout << "Обработка коллизии круг-круг" << std::endl;
}
// Коллизия круг-квадрат
static void collide(Circle&, Square&) {
std::cout << "Обработка коллизии круг-квадрат" << std::endl;
}
// Коллизия квадрат-круг
static void collide(Square&, Circle&) {
std::cout << "Обработка коллизии квадрат-круг" << std::endl;
}
// Коллизия квадрат-квадрат
static void collide(Square&, Square&) {
std::cout << "Обработка коллизии квадрат-квадрат" << std::endl;
}
};
// Типы для многометода
typedef Loki::Typelist<Circle, Loki::Typelist<Square, Loki::NullType>> ShapeTypes;
// Определение диспетчера многометода
typedef Loki::FunctorDispatcher<void, LOKI_TYPELIST_2(Shape&, Shape&)> Dispatcher;
// Определение многометода
typedef Loki::MultiMethods<ShapeTypes, ShapeTypes, Dispatcher, CollisionDetector> Collider;
int main() {
Collider collider;
Circle c1, c2;
Square s1, s2;
// Вызов метода в зависимости от динамических типов
Shape* p1 = &c1;
Shape* p2 = &s1;
collider.go(*p1, *p2); // Вызовет CollisionDetector::collide(Circle&, Square&)
return 0;
} |
|
constexpr или автоматический вывод типов. Во-вторых, сложный шаблонный код может привести к увеличению времени компиляции и непонятным ошибкам. Я сталкивался с ситуацией, когда одна неверная специализация шаблона в Loki приводила к каскаду из 50+ ошибок компиляции, разобраться с которыми могли только гуру метапрограммирования. Еще одна проблема — поддержка библиотеки. С момента выхода книги "Modern C++ Design" прошло много лет, и поддержка Loki не всегда была стабильной. Несмотря на то, что существуют форки и обновлённые версии, они могут быть несовместимы между собой.
С появлением новых стандартов C++ многие техники, представленные в Loki, были включены в стандартную библитеку или реализованы более элегантно с помощью современных возможностей языка. Например, шаблоны с переменным числом аргументов (variadic templates) делают типовые списки более естественными и удобными:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| // Современная реализация типового списка
template<typename... Types>
struct TypeList {};
// Получение типа по индексу
template<std::size_t N, typename... Types>
struct TypeAt;
template<typename Head, typename... Tail>
struct TypeAt<0, Head, Tail...> {
using type = Head;
};
template<std::size_t N, typename Head, typename... Tail>
struct TypeAt<N, Head, Tail...> {
using type = typename TypeAt<N-1, Tail...>::type;
}; |
|
1. Boost.Hana — библиотека метапрограммирования, использующая возможности C++14 и предлагающая элегантный синтаксис для работы с типами, последовательностями и преобразованиями.
2. Boost.MP11 — легковесная библиотека для метапрограммирования, оптимизированная для C++11/14/17, предлагающая алгоритмы для работы с типовыми списками, аналогичные алгоритмам STL.
3. compile-time-regular-expressions (CTRE) — библиотека, которая позволяет анализировать регулярные выражения на этапе кмпиляции, используя возможности C++17/20.
4. {fmt} или std::format (C++20) — современные замены устаревшему форматированому выводу, реализованные с использованием компиляторного времени для проверки строк формата.
Появление концепцій (concepts) в C++20 также предоставило новый мощный инструмент для метапрограммирования, позволяющий накладывать ограничения на шаблонные параметры и получать более понятные сообщения об ошибках:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| #include <concepts>
#include <iostream>
#include <string>
// Определение концепта
template<typename T>
concept Printable = requires(T a) {
{ std::cout << a } -> std::same_as<std::ostream&>;
};
// Функция, использующая концепт
template<Printable T>
void print(const T& value) {
std::cout << value << std::endl;
}
int main() {
print(42); // OK
print("Hello"); // OK
print(std::string("World")); // OK
// Но если бы мы попробовали использовать тип, который
// нельзя вывести в std::cout, получили бы четкую ошибку
return 0;
} |
|
Сравнение и совместное использование библиотек
Выбор правильной библиотеки для конкретного проекта — это искуство, требующее понимания не только технических характеристик, но и контекста задачи. POCO, ACE и Loki — три совершенно разных инструмента, каждый со своей философией и областью применения. Их сравнение напоминает попытку решить, что лучше: молоток, отвертка или плоскогубцы. Ответ очевиден: всё зависит от задачи.
POCO выигрывает в ситуациях, когда требуется быстрая разработка кроссплатформенных приложений с сетевыми возможностями. Её API интуитивно понятен и близок к современному C++, что снижает порог входа. В одном из проектов я наблюдал, как начинающий разработчик всего за неделю создал полноценное клиент-серверное приложение на POCO, хотя до этого имел опыт только с настольными программами.
ACE доминирует там, где критична производительность, надежность или необходимы специфические паттерны для асинхронного взаимодействия. Эта библиотека сложна в освоении, но незаменима в высоконагруженных серверных приложениях. Я наблюдал систему обработки биржевых ордеров, написанную на ACE, которая стабильно справлялась с нагрузкой более 50 000 транзакций в секунду, в то время как аналогичное решение на более современных технологиях "задыхалось" уже при 10 000.
Loki — это специализированный инструмент для метапрограммирования и реализации сложных паттернов проектирования. Он идеален когда нужна гибкость в конфигурации компонентов или генерация кода на этапе компиляции. Loki не предназначен для повседневных задач, но может сэкономить тысячи строк кода и множество ошибок в сложных архитектурах.
Если сравнивать библиотеки по скорости разработки, POCO безусловно лидирует. ACE требует больше подготовки и планирования, а Loki зачастую подразумевает серьезные теоретические знания в области шаблонов и метапрограммирования. По производительности в большинстве сценариев ACE опережает конкурентов. Его низкоуровневые оптимизации и минимальные накладные расходы делают его предпочтительным выбором для систем с высокой нагрузкой.
Интересно, что эти библиотеки не обязательно использовать по отдельности. На практике часто встречаются проекты, где они дополняют друг друга. Например, базовая структура приложения может быть построена на POCO для быстрой разработки, наиболее критичные компоненты могут использовать ACE для максимальной производительности, а сложные архитектурные абстракции могут быть реализованы с помощью Loki.
Рассмотрим пример системы анализа рыночных данных в реальном времени:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
| // Компонент на ACE для высокопроизводительного получения данных
class MarketDataReceiver : public ACE_Task<ACE_MT_SYNCH> {
private:
ACE_Message_Queue<ACE_MT_SYNCH> message_queue_;
public:
int svc() override {
// Бесконечный цикл обработки входящих данных
while (1) {
ACE_Message_Block* mb;
if (message_queue_.dequeue_head(mb) == -1)
break;
// Обработка блока данных...
// ...
mb->release();
}
return 0;
}
// Метод для добавления новых данных
int put_data(const std::string& data) {
ACE_Message_Block* mb = new ACE_Message_Block(data.size() + 1);
mb->copy(data.c_str(), data.size() + 1);
return message_queue_.enqueue_tail(mb);
}
};
// Компонент на POCO для веб-интерфейса
class AnalyticsWebHandler : public Poco::Net::HTTPRequestHandler {
public:
void handleRequest(Poco::Net::HTTPServerRequest& request,
Poco::Net::HTTPServerResponse& response) override {
response.setContentType("application/json");
// Формируем JSON с результатами анализа
Poco::JSON::Object result;
// ...заполнение объекта...
std::ostream& out = response.send();
result.stringify(out);
}
};
// Фабрика на Loki для создания различных типов аналитики
typedef Loki::Factory<Analyzer, std::string> AnalyzerFactory;
class AnalyticsEngine {
private:
MarketDataReceiver receiver_;
AnalyzerFactory factory_;
public:
AnalyticsEngine() {
// Регистрация типов анализаторов
factory_.Register("moving_average", []() { return new MovingAverageAnalyzer(); });
factory_.Register("volatility", []() { return new VolatilityAnalyzer(); });
// Запуск приемника данных
receiver_.activate();
}
// Получение аналитики определенного типа
std::unique_ptr<Analyzer> createAnalyzer(const std::string& type) {
return std::unique_ptr<Analyzer>(factory_.CreateObject(type));
}
// Добавление новых рыночных данных
void addMarketData(const std::string& data) {
receiver_.put_data(data);
}
}; |
|
При совместном использывании библиотек возникают определенные сложности. Например, у каждой из них может быть собственная модель обработки ошибок, свои классы для работы со строками или временем, что создает потенциальные конфликты. В такях случаях рекомендуется выбрать одну библиотеку в качестве "основной" и использовать адаптеры для интеграции с другими.
Критерии выбора подходящей библиотеки для конкретного проекта:
1. Масштаб и сложность проекта. Для небольших проектов или прототипов POCO часто является оптимальным выбором благодаря простоте и скорости разработки. Для крупных систем ACE предоставляет больше контроля и масштабируемости.
2. Требования к производительности. Если система должна обрабатывать тысячи запросов в секунду с минимальной задержкой, ACE предпочтительнее.
3. Кроссплатформенность. Все три библиотеки поддерживают различные платформы, но POCO и ACE имеют более надежную кроссплатформенную совместимость.
4. Команда разработки. Опыт и предпочтения команды играют важную роль. ACE имеет крутую кривую обучения, в то время как POCO более интуитивен для большинства разработчиков.
5. Требования к метапрограммированию. Если проект требует сложных абстракций или генерации кода на этапе компиляции, Loki может быть неоценим.
Интеграция этих библиотек в существующие проекты требует осторожного подхода. Для начала стоит выделить компоненты, которые могут получить наибольшую выгоду от замены или дополнения новой библиотекой. Например, в монолитном приложении можно начать с рефакторинга сетевого взаимодействия для использования POCO или ACE, сохраняя остальную функциональность нетронутой. При работе с этими библиотеками важно также учитывать эволюцию стандарта C++. Многие возможности, которые раньше были уникальными для POCO или Loki, теперь доступны в стандартной библиотеке C++17/20. Это не обесценивает данные библиотеки, но может влиять на решение об их использовании в новых проектах.
Где скачать Билиотеку Loki и найти клас NullType?
Читаю книгу Александреску и пытаюсь проверить и разобраться в предлагаемых приёмах программирования... Подключение библиотеки ACE в visual studio
Добрый день. Необходимо подключить библиотеку ACE в Visual studio. Не смог найти подробного... Установка библиотеки ACE
В общем-то вопрос простой: устанавливаю библиотеку, не могу понять, как её ставить, ссылка на нее... POCO
Кто юзал POCO и стоит ли ее юзать? Какие отзывы?
----------------------------------... Как правильно установить POCO C++ Libraries и протестировать?
Как правильно установить данную библиотеку и протестировать? ( VC++2010 )
Возможно кто нибудь... POCO Net lib утечка
имею код из примеров поставляемых с либой, единственное, что я добавил это переменная string text
... Сборка POCO проекта
Запускаю файл
build_vs100.cmd
и батник создает кучу файлов с расширением lib.
Копирую их в... Механизм сообщений в POCO
Добрый день!
Дайте пожалуйста ссылки на документацию по POCO. Особенно интересует механизм... C++ poco, TCPSerer, vector
#include "Poco/Net/ServerSocket.h"
#include "Poco/Net/StreamSocket.h"
#include... Poco/Net и HTTP
Есть банальный пример:
#include <Poco/Net/HTTPClientSession.h>
#include <Poco/Net/HTTPRequest.h>... библиотека POCO максимальный размер массива для receiveFrame
Доброй ночи друзья!
Возникла у меня беда с библиотекой Poco.
char receiveBuff;
Context... Скрестить Poco и VS2019
Добрый день.
Имеется Visual Studio 2019 (vs160 как я понимаю в их терминологии)
Скачал Poco...
|
Спасибо за статью!
