Передача данных

[m_ax]

libsig++ Хороший вариант

Если нехочется прикручивать всю библиотеку то можно сделать так:

Код

C++ (Qt)
#include <iostream>
 
using namespace std;
 
 
template <class T, typename U>
class Signal
{
public:
    Signal() {
        _obj = 0;
        _slot = 0;
    }
    void operator()(const U& val) {
        if (_obj) {
            (_obj->*_slot)(val);
        }
    }
    void connect(T *obj, void (T::*slot)(const U &)) {
        _obj = obj;
        _slot = slot;
    }
 
private:
    T *_obj;
    void (T::*_slot)(const U &);
};
 
 
template<class T>
class Sender
{
public:
    Sender(){}
    Signal<T, int> signal;
    void run() {
        signal(123);
    }
};
 
class Receiver
{
public:
    Receiver() {}
    void slot(const int &x) {
        cout << x << endl;
    }
};
 
int main()
{
    Sender<Receiver> sender;
    Receiver receiver;
    sender.signal.connect(&receiver, &Receiver::slot);
 
    sender.run();
 
    return 0;
}
 
 

Это фактически сильно упрощённая схема сигнал-слот, реализованая в libsig++

[deaks]

да не, я же говорю все планирую делать через Object. У его интерфейсов можно вызывать функции getData, - что-то типа того, которые возвращают данные объекта в зависимости от параметра, который указывает на этот объект.
У меня сейчас именно так и реализовано, но при этом все данные классов зашиты в структуры, которые друг от друга наследуются. Но тут возникает неприятный момент - в самом классе, в котором описана структура переменных, приходится ведь работать через данную структуру(ахинея какая-та получается), напрямую в переменную уже не запишешь. Код состоит сплошь из имен структуры. В общем все это как-то криво выглядит  - примерно так:

Код:

	airData._Va = airData._V = airData.V.Length();

	if(airData._Va < 0.5) 
		airData._Va = 0.5;

	airData.betaR = asin(airData.V.z/ airData._Va);

	if(fabs(airData.V.y) < 0.01 && fabs(airData.V.x) < 0.01)
		airData.alphaR = 0.;
	else
		airData.alphaR = atan2(airData.-V.y, airData.V.x);

	airData.alpha = airData.alphaR * M_C57;
	airData.beta = airData.betaR * M_C57;

[ruzik]

Может я не правильно что-то понял, но почему бы не сделать один абстрактный класс, со статической функцией, а классы А и Б просто унаследовать от этого класса, ну а когда в классе А изменяется переменная, вызывать эту функцию

[m_ax]

Вся проблема, как я понял, в синтаксическом удобстве. Нет?

[ruzik]

Вся проблема, как я понял, в синтаксическом удобстве. Нет?

Я думаю под "изящным вариантом" автор подразумевает наиболее быстрый и легкий способ, так что можно сказать-да, в синтаксическом удобстве

[deaks]

именно так, товарищи) синтаксическое удобство

[ruzik]

Ну тогда я думаю что это самое простое и быстрое решение

Код:

почему бы не сделать один абстрактный класс, со статической функцией, а классы А и Б просто унаследовать от этого класса, ну а когда в классе А изменяется переменная, вызывать эту функцию

[m_ax]

Может я не правильно что-то понял, но почему бы не сделать один абстрактный класс, со статической функцией, а классы А и Б просто унаследовать от этого класса, ну а когда в классе А изменяется переменная, вызывать эту функцию

Я что то не улавливаю причинно-следственную связь..   Видимо уже не соображаю под вечер))

[ruzik]

Постараюсь объяснить как смогу:

Код:

class A
{
public:
static void qwerty();
vitrual void doIt();
}
void A::qwerty()
{
void doIt();
}
class B : public A
{
private:
 int a;
public:
int set_a(int ab);
}
int B::set_a(int ab)
{
a=ab;
qwerty();
}
class C : public A
{
void doIt();
}
void C::doIt()
{
IamDoIt(); //это то что надо сделать
}

Вроде должно работать, хотя и не факт 
класс А-это "папа"
B и С -наследуемые

[m_ax]

Боюсь это работать не будет.
Статические функции класса могут юзать только статические переменные и статические же функции.

[ruzik]

Не знал

[trot]

Типичный случай патерна "Подписчик-издатель".
Примерно следующая схема.
Объекта класса А изменяет какую-то переменную, после этого он посылает сигнал оповещения, о том что значение переменной изменилось. Те объекты, которые следят за изменением этой переменной должны подписаться на получение оповещение.
Я реализовал у себя следующим образом.
1. Создал класс С (по сути это интерфейс), который будет заниматься оповещением своих подписчиков.

Код:

class С 
{

public:
	С();
	~Сe();

	void addObserver(Observer *);		//добавляет слушателя
	void notifyObservers(Observer * = 0);	//оповещает слушателей, параметром является тот объект, который вызвал оповещение 				           //этот параметр нужен для того, чтобы не запускать update самого себя
private:
	QList<Observer *>	* m_listObserver;		//хранилище слушателей
	
};
void Observable::addObserver(Observer * o){
	if(!m_listObserver->contains(o))
		m_listObserver->append(o);			
}

void Observable::notifyObservers(Observer * o){
	for(int i=0; i<m_listObserver->count(); i++){
		if(o!=m_listObserver->at(i))
			m_listObserver->at(i)->update(this);
	}
}

2. Создаем класс А (тот класс, который меняет переменную) наследуемый от класса (интерфейса) С.
3. Создаем интерфейс D с виртуальным методом update.
4. Создаем класс В (тот класс, который следит за изменением переменной) наследуемый от интерфейса В.
5. Далее связываем издателя с подписчиком, т.е. вызываем метод addObserver с параметром интерфейса С.
6. Когда объекта класса А (издатель) меняет переменную, то он выполняет метод notifyObservers, который переберает всех подписчиков и выполняет их интерфейсный метод update ().
Примерно так. Это я подсмотрел, как данный патерн реализован в стандартной библиотеки java.