# signal

***

**1. Observer Design Pattern**

```cpp
class Subject {
public:
  vector<Observer*> observers;
  void addObserver(Observer* observer) { observers.push_back(observer); }
  void notifyObservers() { for (auto& observer : observers) observer->update(this); }
};

class Observer {
public:
  virtual void update(Subject* subject) = 0;
};
```

**2. Event Handling**

```cpp
class EventListener {
public:
  virtual void onEvent(Event* event) = 0;
};

class EventManager {
public:
  vector<EventListener*> listeners;
  void addListener(EventListener* listener) { listeners.push_back(listener); }
  void dispatchEvent(Event* event) { for (auto& listener : listeners) listener->onEvent(event); }
};
```

**3. Asynchronous Programming (Callbacks)**

```cpp
void asynchronousOperation() {
  // Perform asynchronous operation...
  // Once operation completes, call callback function
  callbackFunction(result);
}
```

**4. Slot-Based Event Handling**

```cpp
class Signal {
public:
  std::map<Slot, std::function<void()>> slots;
  void emit() { for (auto& [slot, func] : slots) func(); }
};

int main() {
  Signal signal;
  signal.connect([&] { std::cout << "Slot triggered!" << std::endl; });
  signal.emit();
}
```

**5. Inter-Thread Communication**

```cpp
std::mutex m;
std::condition_variable cv;
bool ready = false;

void producerThread() {
  std::lock_guard<std::mutex> lock(m);
  // Produce data...
  ready = true;
  cv.notify_one();
}

void consumerThread() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock, [] { return ready; });
  // Consume data...
}
```

**6. State Machine**

```cpp
enum class State {
  Idle,
  Running,
  Paused,
  Finished
};

class StateMachine {
public:
  StateMachine() : state(State::Idle) {}
  State state;
  void transition(State newState) { switch (state) { case State::Idle: ...; case State::Running: ...; ... } }
};
```

**7. Finite State Machine (FSM)**

```cpp
class FSM {
public:
  std::map<State, std::function<void(State)>> transitions;
  State state;
  void transition(State newState) { transitions[state](newState); }
};
```

**8. Reactive Programming**

```cpp
#include <rxcpp/rx.hpp>

auto observable = rxcpp::observable<>::create([](rxcpp::subscriber<int> s) {
  s.on_next(1);
  s.on_next(2);
  s.on_next(3);
  s.on_completed();
});

observable.subscribe(
  [](int v) { std::cout << "Received: " << v << std::endl; },
  []() { std::cout << "Completed" << std::endl; }
);
```

**9. Pub-Sub (Publish-Subscribe) System**

```cpp
class Publisher {
public:
  std::vector<Subscriber*> subscribers;
  void publish(Message* message) { for (auto& subscriber : subscribers) subscriber->onMessage(message); }
};

class Subscriber {
public:
  virtual void onMessage(Message* message) = 0;
};
```

**10. Model-View-Controller (MVC) Design Pattern**

```cpp
class Model {
public:
  std::vector<Observer*> observers;
  void update() { for (auto& observer : observers) observer->update(this); }
};

class View : public Observer {
public:
  void update(Model* model) { // Update view based on model changes }
};

class Controller {
public:
  Model* model;
  View* view;
  void onUserEvent() { model->update(); }
};
```

**11. Logging**

```cpp
class Logger {
public:
  void log(const std::string& message) { // Log message somewhere }
};

void logSomething() {
  Logger::log("Something happened!");
}
```

**12. Event Logging**

```cpp
class EventLogger {
public:
  void logEvent(const Event& event) { // Log event to a database or file }
};

void logEvent(const Event& event) {
  EventLogger::logEvent(event);
}
```

**13. Error Handling**

```cpp
void functionThatCanFail() {
  try {
    // Do something that can fail
  } catch (const std::exception& e) {
    // Handle error gracefully
  }
}
```

**14. Asynchronous Error Handling**

```cpp
void functionThatCanFailAsync() {
  operation.then([]() {
    // Success handler
  }, [](exception_ptr e) {
    // Error handler
  });
}
```

**15. Exception Handling**

```cpp
int main() {
  try {
    // Do something that can throw an exception
  } catch (const std::exception& e) {
    // Handle exception
  }
}
```

**16. Error Handling with Signal (Boost.Signals2)**

```cpp
#include <boost/signals2.hpp>

boost::signals2::signal<void(int)> errorSignal;
errorSignal.connect([](int error) { std::cerr << "Error: " << error << std::endl; });
void functionThatCanFail() { errorSignal(42); }
```

**17. Event Dispatching with Signal (Boost.Signals2)**

```cpp
#include <boost/signals2.hpp>

boost::signals2::signal<void()> event_signal;
void onEvent() { event_signal(); }
int main() {
  event_signal.connect([]() { std::cout << "Event occurred!" << std::endl; });
  onEvent();
  return 0;
}
```

**18. Slot-Based Event Handling (Qt)**

```cpp
#include <QtCore/QObject>
#include <QtCore/QEvent>

class MyObject : public QObject {
  Q_OBJECT
public:
  void customEvent(QEvent* e) { // Handle custom event }
};
int main() {
  MyObject obj;
  QEvent* event = new QEvent(QEvent::Type::User);
  QApplication::postEvent(&obj, event);
  return 0;
}
```

**19. Qt Object-to-Object Communication**

```cpp
#include <QtCore/QCoreApplication>
#include <QtCore/QMetaObject>

class Emitter : public QObject {
  Q_OBJECT
public slots:
  void emitSignal() { emit customSignal(); }
};

QObject* receiver = new QObject();

int main(int argc, char* argv[]) {
  QCoreApplication app(argc, argv);
  QMetaObject::invokeMethod(receiver, "customSlot", Qt::QueuedConnection);
  return app.exec();
}
```

**20. Dynamic Signal and Slot Connection (Qt)**

```cpp
#include <QtCore/QObject>
#include <QtCore/QMetaObject>

class Parent : public QObject {
  Q_OBJECT
public:
  Q_INVOKABLE void doSomething(QString message) { std::cout << "Parent::doSomething" << std::endl; }
};

int main() {
  Parent parent;
  QMetaObject::invokeMethod(&parent, "doSomething", Qt::DirectConnection, Q_ARG(QString, "Hello, world!"));
  return 0;
}
```

**21. Qt Signal and Slot with Lambda**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void()> mySignal;
  MyObject() { mySignal.connect([this]() { std::cout << "Signal emitted!" << std::endl; }); }
};
```

**22. Inter-Thread Qt Signal-Slot Communication**

```cpp
#include <QtCore/QCoreApplication>
#include <QtCore/QThread>
#include <QtCore/QMetaObject>

class WorkerThread : public QThread {
  void run() {
    QMetaObject::invokeMethod(receiver, "update", Qt::QueuedConnection, Q_ARG(QString, "Message from thread"));
  }
};

int main(int argc, char* argv[]) {
  QCoreApplication app(argc, argv);
  WorkerThread workerThread;
  workerThread.start();
  return app.exec();
}
```

**23. Qt Signal and Slot with Custom Data Type**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(QString)> mySignal;
  MyObject() { mySignal.connect([](QString message) { std::cout << message.toStdString() << std::endl; }); }
};
```

**24. Qt Signal and Slot with Default Arguments**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(QString, int)> mySignal;
  MyObject() { mySignal.connect([](QString message, int count = 0) { std::cout << message.toStdString() << " (" << count << ")" << std::endl; }); }
};
```

**25. Qt Signal and Slot with Overloaded Functions**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(int)> mySignal;
  QSignal<void(QString)> mySignal;
  MyObject() {
    mySignal<int>.connect([](int value) { std::cout << "int: " << value << std::endl; });
    mySignal<QString>.connect([](QString message) { std::cout << "string: " << message.toStdString() << std::endl; });
  }
};
```

**26. Qt Signal and Slot with Multiple Receivers**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(QString)> mySignal;
  MyObject() {
    mySignal.connect([](QString message) { std::cout << "Receiver 1: " << message.toStdString() << std::endl; });
    mySignal.connect([](QString message) { std::cout << "Receiver 2: " << message.toStdString() << std::endl; });
  }
};
```

**27. Qt Signal and Slot with Disconnection**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(QString)> mySignal;
  MyObject() {
    QMetaObject::invokeMethod(this, "emitSignal", Qt::QueuedConnection);
  }
  Q_SLOT void emitSignal() {
    connect(this, &MyObject::mySignal, this, &MyObject::onSignal, Qt::QueuedConnection);
    mySignal.emit("Hello, world!");
  }
  Q_SLOT void onSignal(QString message) { std::cout << message.toStdString() << std::endl; disconnect(this, &MyObject::mySignal, this, &MyObject::onSignal); }
};
```

**28. Qt Signal and Slot with Blocking Queues**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>
#include <QtCore/QCoreApplication>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(QString)> mySignal;
  MyObject() {
    mySignal.connect([](QString message) { std::cout << message.toStdString() << std::endl; });
  }

  void emitSignalBlocking() {
    auto future = QCoreApplication::postEvent(this, new QEvent(QEvent::Type::User));
    future.waitForFinished();
  }
};
```

**29. Qt Signal and Slot with Queued Connections**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(QString)> mySignal;
  MyObject() {
    mySignal.connect([](QString message) { std::cout << message.toStdString() << std::endl; }, Qt::QueuedConnection);
  }
};
```

**30. Qt Signal and Slot with Direct Connections**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
public:
  QSignal<void(QString)> mySignal;
  MyObject() {
    mySignal.connect([](QString message) { std::cout << message.toStdString() << std::endl; }, Qt::DirectConnection);
  }
};
```

**31. Qt Signal and Slot with Property Changes**

```cpp
#include <QtCore/QObject>
#include <QtCore/QSignal>

class MyObject : public QObject {
  Q_OBJECT
  Q_PROPERTY(QString message READ message WRITE setMessage)
public:
  MyObject() : m_message("Hello, world!") {}
  QString message() const { return m_message; }
  void setMessage(const QString& message) {
    if (m_message == message) { return; }
    m_message = message;
    emit messageChanged(m_message);
  }
  Q_SIGNAL void messageChanged(const QString&);
private:
  QString m_message;
};

int main(int argc, char* argv[]) {
  MyObject object;
  QObject::connect(&object, &MyObject::messageChanged, [](const QString& message) { std::cout << "Message changed: " << message.toStdString

```