В 4.6.2 под Linux тож нормуль
Хотя это
воспроизводится.

Скан??? Лучше написать нормальный виджет с возможностью редактирования клеток..
Всё это реализуется через переопределения событий.

Хотя я бы ещё посмотрел в сторону модель-представление. Посмотрите на пример у тролей, где они реализовали своё представление Chart Example вроде.

Изменил архитектуру ssc
Теперь сигнал может принимать два аргумента и связываться с функциями вида:

C++ (Qt)
// не методы класса
T_return (*fun_type)(T_arg1, T_arg2);
T_return (*fun_type)(T_arg1);
T_return (*fun_type)();
 
// методы класса
T_return (T_receiver::*mem_fun_type)(T_arg1, T_arg2);
T_return (T_receiver::*const_mem_fun_type)(T_arg1, T_arg2) const;
T_return (T_receiver::*mem_fun_type)(T_arg1);
T_return (T_receiver::*const_mem_fun_type)(T_arg1) const;
T_return (T_receiver::*mem_fun_type)();
T_return (T_receiver::*const_mem_fun_type)() const;
 

Сам интерфейс практически не изменился, пример:

C++ (Qt)
#include <iostream>
#include <string>
#include "signal_slot.h"
 
void func(const std::string &str) {
    std::cout << "func slot: " << str << std::endl;
}
 
class A
{
public:
    A() {
        std::cout << "A()" << std::endl;
    }
    ~A() {
        std::cout << "~A()" << std::endl;
    }
 
    ssc::signal<const std::string &> sig_fun;  /* теперь нужно тип аргумента расписывать подробно!
                                                                       И чтоб он в точности соответствовал арг. слота  */
    ssc::signal<int> sig_1;
    ssc::signal<const std::string &, int> sig_2;
 
    void run() const {
        sig_fun("Hello!");
        sig_1(2011);
        sig_2("Hello World!", 1234567);
    }
};
 
class B : public ssc::trackable
{
public:
    B() {
        std::cout << "B()" << std::endl;
    }
    ~B() {
        std::cout << "~B()" << std::endl;
    }
 
    void slot1(int x) const {
        std::cout << "slot1: x = " << x << std::endl;
    }
    int slot2(const std::string &str, int x) const {
        std::cout << "slot2: " << str << "  x = " << x << std::endl;
        return 67;
    }
};
 
int main()
{
    A *a = new A;
    B *b = new B;
 
    connect(a->sig_fun, func);
    connect(a->sig_1, b, &B::slot1);
    connect(a->sig_2, b, &B::slot2);
 
    a->run();
 
    delete a;
    delete b;
    return 0;
}
 

P.S. Valgrind сказал, что утечек нет))

 

Млин! Ещё одна опечатка выявилась, которая приводит к утечке :
В файле smart_ptr.h в методе try_destroy():

C++ (Qt)
template <class T>
inline void smart_ptr<T>::try_destroy()
{
    if (!_obj)
        return;
 
    if ((*_counter) == 1) {
        delete _counter;
        _counter = 0;
        delete _obj;
        _obj = 0;
    }
}
 

Забыл уменьшить счётчик _counter
Правильно так:

C++ (Qt)
template <class T>
inline void smart_ptr<T>::try_destroy()
{
    if (!_obj)
        return;
 
    if ((*_counter)-- == 1) {
        delete _counter;
        _counter = 0;
        delete _obj;
        _obj = 0;
    }
}
 

Выявил тут один баг, когда внедрял эту штуку в програмку..
Вобщем возникала проблема, при использовании типа void

C++ (Qt)
class A
{
public:
    ssc::signal<void> sig;
};
 

Сигнал sig - соединяется с функциями которые возвращают T_return и не имеют аргументов:

C++ (Qt)
class B : public ssc::trackable
{
public:
    int slot() const {   // Вот например с такой функцией
        return 123;
    }
};
 

Сейчас проблема решена с помощью специализации шаблонов на тип void..
Кстати, такой приём в стандартной библиотеке применён и для std::vector<bool>  

Исходники прилагаются

И так, общими усилиями мы это сделали))
Сейчас всё работает и думаю уже приобрело законченную форму..
Ну во всяком случае можно немного успокоится)

Я тут внёс ещё одно изменение, которое не отражается на интерфейсе сигнала, но так думаю, будет более нагляднее: изменил в base_connection

C++ (Qt)
virtual void operator()(const T_arg &) const = 0
 

на

C++ (Qt)
virtual void handle_evant(const T_arg &) const = 0;
 

приаттачеваю на последок исходники release версии

Всем спасибо)

Сделал)
Список изменений:
1) Ввёл в базовый класс (base_connection) функцию compare замещающую функции operator==()
2) Объединил указатели на функции в union
3) Заменил все if (_index) ... на switch(_index)
4) Дополнил функционал функцией disconnect, которая возвращает true если соединение было удачно разорвано и false  в противном случае. Также теперь bool возвращают и функции connect - true в случае успешного соединения, false - в противном случае.
5) По мелочи: причесал код...

Исходники для тестирования прилагаются.

Это да, но я сейчас ввёл функцию compare:

C++ (Qt)
template <class T_arg>
class base_connection
{
public:
    base_connection() {}
    virtual ~base_connection() {}
    virtual void operator() (const T_arg &) const = 0;
    virtual bool valid() const = 0;
    virtual bool compare(base_connection<T_arg> *) const = 0;
};
 

которая сравнивает не сами указатели на соединения непосредственно указатели на receiverОв и указатели на функции классов: (вот пример её реализации в классе mem_func_connection)

C++ (Qt)
bool compare(base_connection<T_arg> *bc) const {
        mem_func_connection<T_receiver, T_return, T_arg> *mfc = dynamic_cast<mem_func_connection<T_receiver, T_return, T_arg> *>(bc);
        if (mfc && (mfc->_receiver == _receiver)) {
            if (_index == 1)
                return (mfc->_slot_1 == _slot_1);
            if (_index == 2)
                return (mfc->_slot_2 == _slot_2);
            if (_index == 3)
                return (mfc->_slot_3 == _slot_3);
            if (_index == 4)
                return (mfc->_slot_4 == _slot_4);
        }
        return false;
    }
 

аналогично и в случае func_conection:

C++ (Qt)
bool compare(base_connection<T_arg> *bc) const {
        func_connection<T_return, T_arg> *fc = dynamic_cast<func_connection<T_return, T_arg>* >(bc);
        if (fc) {
            if (_index == 1)
                return (fc->_slot_1 == _slot_1);
            if (_index == 2)
                return (fc->_slot_2 == _slot_2);
        }
        return false;
    }
 

и теперь в самой функции connect (класс signal):

C++ (Qt)
void connect(base_connection<T_arg> *c) {
        for (_iterator it = _list.begin(); it != _list.end(); it++) {
            if (c->compare(*it)) {
                delete c;
                return;
            }
        }
        _list.push_back(c);
    }
 

Такой вариант работает, я проверял))
Хорошая идея, спасибо)

В смысле?
Я должен их сравнивать, чтобы не дублировать соединения.. Если в списке уже имеется такое же соединение то и нефиг его туда вновь заносить..
Потом, мне нужно в саму функцию compare я передаю указатель и если соединение уже создано ранее, то я уничтожаю текущее.\
Или я чего то не понммаю?

Понял в чём баг..
Но в самой вункции connect  я сравниваю именно указатели

C++ (Qt)
void connect(base_connection<T_arg> *c) {
        for (_iterator it = _list.begin(); it != _list.end(); it++) {
            if (c == *it) {
                delete c;
                return;
            }
        }
        _list.push_back(c);
 

Может здесь целесообразнее объявить функцию сравнения указателей?
Например:

C++ (Qt)
virtual bool compare(base_connection<T_arg> *) const = 0;
 

Так, сделал по совету brankovic: определил оператор

C++ (Qt)
template <class T_arg>
class base_connection
{
public:
    base_connection() {}
    virtual ~base_connection() {}
    virtual void operator() (const T_arg &) const = 0;
    virtual bool valid() const = 0;
    virtual bool operator==(base_connection<T_arg> *) const = 0;  // Вот этот оператор
};
 

И всё заработало, но.. Но работает только так:

C++ (Qt)
class signal
{
public:
    signal() {}
    ~signal() {
        for (_iterator it = _list.begin(); it != _list.end(); it++) {
            delete *it;
        }
        _list.clear();
    }
 
    void operator() (const T_arg &arg) const {
        for (_const_iterator it = _list.begin(); it != _list.end(); it++) {
            if ((*it)->valid())
                (*it)->operator()(arg);
        }
    }
 
    template <class T1, class T2, class T3> friend class mem_func_connection;
    template <class T1, class T2> friend class func_connection;
 
private:
    std::list<base_connection<T_arg>* > _list;
    typedef typename std::list<base_connection<T_arg>* >::iterator _iterator;
    typedef typename std::list<base_connection<T_arg>* >::const_iterator _const_iterator;
 
    void connect(base_connection<T_arg> *c) {
        for (_iterator it = _list.begin(); it != _list.end(); it++) {
            if (c->operator ==(*it)) {  /* Вот здесь приходится явно вызывать operator==(...) 
                                                          а если просто c == *it то не сработывает :(   Где подвох?
                                                          я сейчас немного не в состоянии думать))                   */
                delete c;
                return;
            }
        }
        _list.push_back(c);
    }
};
 

Вот полный код signal_slot.h

C++ (Qt)
#ifndef SIGNAL_SLOT_H
#define SIGNAL_SLOT_H
 
#include <list>
#include "smart_ptr.h"
#include <iostream>
 
namespace ssc {
 
template <class T_arg>
class base_connection
{
public:
    base_connection() {}
    virtual ~base_connection() {}
    virtual void operator() (const T_arg &) const = 0;
    virtual bool valid() const = 0;
    virtual bool operator==(base_connection<T_arg> *) const = 0;
};
 
 
class trigger
{
public:
    trigger() : _flag(true) {}
    void set(bool flag) { _flag = flag; }
    bool get() const { return _flag; }
 
private:
    bool _flag;
};
 
class trackable
{
public:
    trackable() {
        spy = smart_ptr<trigger>(new trigger);
    }
    virtual ~trackable() {
        spy->set(false);
    }
    smart_ptr<trigger> spy;
};
 
template <class T_arg>
class signal
{
public:
    signal() {}
    ~signal() {
        for (_iterator it = _list.begin(); it != _list.end(); it++) {
            delete *it;
        }
        _list.clear();
    }
 
    void operator() (const T_arg &arg) const {
        for (_const_iterator it = _list.begin(); it != _list.end(); it++) {
            if ((*it)->valid())
                (*it)->operator()(arg);
        }
    }
 
    template <class T1, class T2, class T3> friend class mem_func_connection;
    template <class T1, class T2> friend class func_connection;
 
private:
    std::list<base_connection<T_arg>* > _list;
    typedef typename std::list<base_connection<T_arg>* >::iterator _iterator;
    typedef typename std::list<base_connection<T_arg>* >::const_iterator _const_iterator;
 
    void connect(base_connection<T_arg> *c) {
        for (_iterator it = _list.begin(); it != _list.end(); it++) {
            if (c->operator ==(*it)) {
                delete c;
                return;
            }
        }
        _list.push_back(c);
    }
};
 
template <class T_return, class T_arg>
class func_connection : public base_connection<T_arg>
{
public:
    typedef T_return (*function_type_1)(T_arg);
    typedef T_return (*function_type_2)(const T_arg &);
 
    func_connection(signal<T_arg> &s, function_type_1 slot) {
        _slot_1 = slot;
        _index = 1;
        s.connect(this);
    }
 
    func_connection(signal<T_arg> &s, function_type_2 slot) {
        _slot_2 = slot;
        _index = 2;
        s.connect(this);
    }
 
    void operator()(const T_arg &arg) const {
        if (_index == 1) {
            (*_slot_1)(arg);
            return;
        }
        if (_index == 2) {
            (*_slot_2)(arg);
            return;
        }
    }
 
    bool valid() const {
        return true;
    }
 
    bool operator==(base_connection<T_arg> *bc) const {
        func_connection<T_return, T_arg> *fc = dynamic_cast<func_connection<T_return, T_arg>* >(bc);
        if (fc) {
            if (_index == 1)
                return (fc->_slot_1 == _slot_1);
            if (_index == 2)
                return (fc->_slot_2 == _slot_2);
        }
        return false;
    }
 
private:
    function_type_1 _slot_1;
    function_type_2 _slot_2;
    int _index;
    func_connection();
    func_connection(const func_connection &);
};
 
template <class T_receiver, class T_return, class T_arg>
class mem_func_connection : public base_connection<T_arg>
{
public:
    typedef T_return (T_receiver::*function_type_1)(T_arg);
    typedef T_return (T_receiver::*function_type_2)(const T_arg &);
    typedef T_return (T_receiver::*function_type_3)(T_arg) const;
    typedef T_return (T_receiver::*function_type_4)(const T_arg &) const;
 
    mem_func_connection(signal<T_arg> &s, T_receiver *obj, function_type_1 slot) {
        _receiver = obj;
        _spy = _receiver->spy;
        _slot_1 = slot;
        _index = 1;
        s.connect(this);
    }
 
    mem_func_connection(signal<T_arg> &s, T_receiver *obj, function_type_2 slot) {
        _receiver = obj;
        _spy = _receiver->spy;
        _slot_2 = slot;
        _index = 2;
        s.connect(this);
    }
 
    mem_func_connection(signal<T_arg> &s, T_receiver *obj, function_type_3 slot) {
        _receiver = obj;
        _spy = _receiver->spy;
        _slot_3 = slot;
        _index = 3;
        s.connect(this);
    }
 
    mem_func_connection(signal<T_arg> &s, T_receiver *obj, function_type_4 slot) {
        _receiver = obj;
        _spy = _receiver->spy;
        _slot_4 = slot;
        _index = 4;
        s.connect(this);
    }
 
    void operator()(const T_arg &arg) const {
        if (_index == 1) {
            (_receiver->*_slot_1)(arg);
            return;
        }
        if (_index == 2) {
            (_receiver->*_slot_2)(arg);
            return;
        }
        if (_index == 3) {
            (_receiver->*_slot_3)(arg);
            return;
        }
        if (_index == 4) {
            (_receiver->*_slot_4)(arg);
            return;
        }
    }
 
    bool valid() const {
        return _spy->get();
    }
 
    bool operator==(base_connection<T_arg> *bc) const {
        mem_func_connection<T_receiver, T_return, T_arg> *mfc = dynamic_cast<mem_func_connection<T_receiver, T_return, T_arg> *>(bc);
        if (mfc && (mfc->_receiver == _receiver)) {
            if (_index == 1)
                return (mfc->_slot_1 == _slot_1);
            if (_index == 2)
                return (mfc->_slot_2 == _slot_2);
            if (_index == 3)
                return (mfc->_slot_3 == _slot_3);
            if (_index == 4)
                return (mfc->_slot_4 == _slot_4);
        }
        return false;
    }
 
private:
    T_receiver *_receiver;
    smart_ptr<trigger> _spy;
    function_type_1 _slot_1;
    function_type_2 _slot_2;
    function_type_3 _slot_3;
    function_type_4 _slot_4;
    int _index;
    mem_func_connection();
    mem_func_connection(const mem_func_connection &);
};
 
template <class T_return, class T_arg>
void connect(signal<T_arg> &s, T_return (*slot)(T_arg)) {
   new func_connection<T_return, T_arg>(s, slot);
}
 
template <class T_return, class T_arg>
void connect(signal<T_arg> &s, T_return (*slot)(const T_arg &)) {
    new func_connection<T_return, T_arg>(s, slot);
}
 
template <class T_receiver, class T_return, class T_arg>
void connect(signal<T_arg> &s, T_receiver *obj, T_return (T_receiver::*slot)(T_arg)) {
    new mem_func_connection<T_receiver, T_return, T_arg>(s, obj, slot);
}
 
template <class T_receiver, class T_return, class T_arg>
void connect(signal<T_arg> &s, T_receiver *obj, T_return (T_receiver::*slot)(const T_arg &)) {
    new mem_func_connection<T_receiver, T_return, T_arg>(s, obj, slot);
}
 
template <class T_receiver, class T_return, class T_arg>
void connect(signal<T_arg> &s, T_receiver *obj, T_return (T_receiver::*slot)(T_arg) const) {
    new mem_func_connection<T_receiver, T_return, T_arg>(s, obj, slot);
}
 
template <class T_receiver, class T_return, class T_arg>
void connect(signal<T_arg> &s, T_receiver *obj, T_return (T_receiver::*slot)(const T_arg &) const) {
    new mem_func_connection<T_receiver, T_return, T_arg>(s, obj, slot);
}
 
}
 
#endif // SIGNAL_SLOT_H
 
 

Спасибо)) Это именно то что нужно
Сейчас сделаем)

Решил дополнить функционал, добавив
1) функцию disconnect, которая бы разрывала соединение
2) В самом соединении connect, вначале проверять, есть ли в списке уже зарегистрированное такое же соединение и если есть, то не вносить его повторно в список.

Но столкнулся с маленькой проблемкой.  Суть которой в следующем:
Поскольку список соединений содержит указатели на объекты base_connection - предоставляющим интерфейс соединения, то манипуляции все происходят через его интерфейс.
Т.е. это означает, что я например, мог бы определить например функцию address в базовой реализации:

C++ (Qt)
template <class T_arg>
class base_connection
{
public:
    base_connection() {}
    virtual ~base_connection() {}
    virtual void operator() (const T_arg &) const = 0;
    virtual bool valid() const = 0;
    virtual long address_obj() const = 0; /* Вот эта новая функция, которая, к примеру,  
                                                                   будет возвращать адрес объекта receivera */
    virtual long address_mem_func() const = 0; /* А это адрес функции (слота) */
};
 

 
Тогда я бы мог перед тем как добавить новое соединение в список, проверить использую пару новых функций не содержится ли уже в списке такое же соединение.

А вот пример реализации этих функция в mem_func_connection:

C++ (Qt)
long mem_func_connection::address_obj() const
{
    return (long)_receiver; // _receiver - это указатель
}
long mem_func_connection::address_mem_func() const
{
    return (long)&_slot; /* _slot - принадлежитодному из 4 типов: 
                                        typedef T_return (T_receiver::*_function_type_1)(T_arg); (N = 1, 2, 3, 4) 
                                        typedef T_return (T_receiver::*_function_type_2)(T_arg) const;
                                        ...
*/
}
 

Но меня мучают сомнения в корректности реализации address_mem_func() const
Хотя формально всё работает..
Дело в том, что как выяснилось sizeof(long) и sizeof(function_type_N) (N = 1,2,3,4) различаются, причём последний в два раза больше чем размкер long.  

Как быть? Куда копать?
Спасибо за помощь)

И вновь обобщил решение))

Теперь с сигналом могут соединятся не только методы класса, но и обычные функции:

C++ (Qt)
int my_func(const std::string &str) {
    std::cout << str << std::endl;
    return str.size();
}
 
class A
{
public:
 
    ssc::signal<std::string> my_signal;
 
    void run() {
        my_signal("Hello Word!");
    }
};
 
int main()
{
    B *b = new B;
    A *a = new A;
 
    connect(a->my_signal, b, &B::slot1);
    connect(a->my_signal, b, &B::slot2);
    connect(a->my_signal, my_function);  // Соединение с обычной функцией
 
    a->run();
 
    delete b;
    delete a;
 
    return 0;
}
 

Далее я изменил название основных классов:
Основным абстрактным классом соединения, предоставляющем интерфейс теперь является

C++ (Qt)
template <class T_arg>
class base_connection
{
public:
    base_connection() {}
    virtual ~base_connection() {}
    virtual void operator() (const T_arg &) const = 0;
    virtual bool valid() const = 0;
};
 

вместо base_signal, что правильнее отражает суть и предназначение этого класса

Соответственно класс signal теперь содержит список всех своих соединений base_connection

C++ (Qt)
std::list<base_connection<T_arg>* > _list;
 

Класс manager_connection переименован в mem_func_connection:

C++ (Qt)
template <class T_receiver, class T_return, class T_arg>
class mem_func_connection : public base_connection<T_arg>
 

и предназначен для создания соединений с методами класса

Появился новый класс func_connection

C++ (Qt)
template <class T_return, class T_arg>
class func_connection : public base_connection<T_arg>
 

перназначенный для создания соединения с обычными функциями

Соответственно появились версии перегруженных функций connection для соединения сигнала с обычными функциями.

Исходники приатачены, прошу потестить.

Обобщил решение))

Теперь при создании объекта signal в классе который будет его имитеть, нужно лишь указать один шаблонный аргумент - T_art:

C++ (Qt)
class A : public ssc::trackable
{
public:
    A(){}
 
    ssc::signal<std::string> my_signal;  /* вот здесь указываем [b]только[/b] 
                                                                 тип передаваемого арг:  std::string */
 
    void run() {
        my_signal("Hello Word!");   // эмитем сигнал
    }
 
};
 

Соединятся сигнал может с любой функцией, представимой в виде:

C++ (Qt)
    typedef T_return (T_receiver::*function_type_1)(T_arg);
    typedef T_return (T_receiver::*function_type_2)(const T_arg &);
    typedef T_return (T_receiver::*function_type_3)(T_arg) const;
    typedef T_return (T_receiver::*function_type_4)(const T_arg &) const;
 

 

Т.е. в дальнейшем всё как обычно:

C++ (Qt)
class B : public ssc::trackable
{
public:
    B() {}
 
    void slot1(const std::string &str) {
        std::cout << "slot1, signal - " << str << std::endl;
    }
 
    int slot2(std::string str) const {
        std::cout << "slot2, signal - " << str << std::endl;
        return 123;
    }
};
 
int main()
{
    B *b = new B;
    A *a = new A;
 
    connect(a->my_signal, b, &B::slot1);
    connect(a->my_signal, b, &B::slot2);
 
    a->run();
 
    delete b;
    delete a;
 
    return 0;
}
 

Исходники прилагаются.