Russian Qt Forum

C++ (Qt)
class AWebNullArgument {};
 
class AWebAbstractArguments
{
public:
    //! Деструктор.
    virtual ~AWebAbstractArguments() {}
 
};
 
template<class Arg1 = AWebNullArgument, class Arg2 = AWebNullArgument>
class AWebDelegateArguments : public AWebAbstractArguments
{
public:
    Arg1 _arg1; Arg2 _arg2;
 
    //! Конструктор.
    AWebDelegateArguments() {}
 
    //! Конструктор.
    AWebDelegateArguments(Arg1 arg1) : _arg1(arg1) {}
 
    //! Конструктор.
    AWebDelegateArguments(Arg1 arg1, Arg2 arg2) : _arg1(arg1), _arg2(arg2) {}
 
    //! Деструктор.
    virtual ~AWebDelegateArguments() {}
 
};
 

C++ (Qt)
#include "awebdelegatearguments.h"
 
class AWebAbstractContainer
{
public:
    //! Деструктор.
    virtual ~AWebAbstractContainer() {}
 
    //! Функция вызова метода объекта.
    virtual void run(AWebAbstractArguments*) = 0;
 
};
 
template<class Class, class Method>
class AWebDelegateContainer : public AWebAbstractContainer
{
public:
    //! Деструктор.
    virtual ~AWebDelegateContainer() {}
 
};
 
template<class Class>
class AWebDelegateContainer<Class, void (Class::*)(void)>
    : public AWebAbstractContainer
{
typedef void (Class::*Method)(void);
 
public:
    //! Конструктор.
    AWebDelegateContainer(Class *c, Method m) : _class(c), _method(m) {}
 
    //! Деструктор.
    virtual ~AWebDelegateContainer() {}
 
    //! Функция вызова метода объекта.
    void run(AWebAbstractArguments*) {(_class->*_method)();}
 
private:
    Class *_class;
    Method _method;
 
};
 
template<class Class, class Arg1>
class AWebDelegateContainer<Class, void (Class::*)(Arg1)>
    : public AWebAbstractContainer
{
typedef void (Class::*Method)(Arg1);
typedef AWebDelegateArguments<Arg1> Args;
 
public:
    //! Конструктор.
    AWebDelegateContainer(Class *c, Method m) : _class(c), _method(m) {}
 
    //! Деструктор.
    virtual ~AWebDelegateContainer() {}
 
    //! Функция вызова метода объекта.
    void run(AWebAbstractArguments *args_i) {
        Args *args = dynamic_cast<Args*>(args_i);
        if(args) (_class->*_method)(args->_arg1);
    }
 
private:
    Class *_class;
    Method _method;
 
};
 
template<class Class, class Arg1, class Arg2>
class AWebDelegateContainer<Class, void (Class::*)(Arg1, Arg2)>
    : public AWebAbstractContainer
{
typedef void (Class::*Method)(Arg1, Arg2);
typedef AWebDelegateArguments<Arg1, Arg2> Args;
 
public:
    //! Конструктор.
    AWebDelegateContainer(Class *c, Method m) : _class(c), _method(m) {}
 
    //! Деструктор.
    virtual ~AWebDelegateContainer() {}
 
    //! Функция вызова метода объекта.
    void run(AWebAbstractArguments *args_i) {
        Args *args = dynamic_cast<Args*>(args_i);
        if(args) (_class->*_method)(args->_arg1, args->_arg2);
    }
 
private:
    Class *_class;
    Method _method;
 
};
 

C++ (Qt)
#include "awebdelegatecontainer.h"
 
class AWebDelegate
{
public:
    //! Конструктор.
    AWebDelegate() : _container(NULL) {}
 
    //! Деструктор.
    virtual ~AWebDelegate() {if(_container) delete _container;}
 
    //! Функция подключения метода объекта.
    template<class Class, class Method>
    void connect(Class *c, Method m) {
        if(_container) delete _container;
        _container = new AWebDelegateContainer<Class, Method>(c, m);
    }
 
    //! Оператор вызова.
    void operator()() {
        AWebDelegateArguments<> args;
        _container->run(&args);
    }
 
    //! Оператор вызова.
    template<class Arg1>
    void operator()(Arg1 arg1) {
        AWebDelegateArguments<Arg1> args(arg1);
        _container->run(&args);
    }
 
    //! Оператор вызова.
    template<class Arg1, class Arg2>
    void operator()(Arg1 arg1, Arg2 arg2) {
        AWebDelegateArguments<Arg1, Arg2> args(arg1, arg2);
        _container->run(&args);
    }
 
private:
    AWebAbstractContainer *_container;
 
};
 

C++ (Qt)
#include "awebdelegate.h"
 
class Base {
public:
    void test1() {qDebug() << "test1()";}
    void test2(int a) {qDebug() << QString("test2(%1)").arg(a);}
    void test3(const QString &b) {qDebug() << QString("test3(%1)").arg(b);}
 
    int problemFunc() {qDebug() << "We are the champions!!!";}
 
};
 
int main(int argc, char *argv[])
{
Base b;
 
AWebDelegate delegate;
 
//OK
delegate.connect(&b, &Base::test1);
delegate();
 
//OK
delegate.connect(&b, &Base::test2);
delegate(10);
 
//OK
delegate.connect(&b, &Base::test3);
delegate("tra-ta-ta");
 
//Fail
delegate.connect(&b, &Base::problemFunc);
delegate();
 
return 0;
}
 

C++ (Qt)
template<typename RetType>
class Foo
{
	public:
 
	RetType run()
	{
		std::cout<<"some type\n";
		return RetType();
	}
};
 
template<>
int Foo<int>::run()
{
	std::cout<<"ret int\n";
	return 1;
}
template<>
void Foo<void>::run()
{
	std::cout<<"void\n";
}
 
int main()
{
	{
		Foo<int> foo;
		foo.run();
	}
 
	{
		Foo<double> foo;
		foo.run();
	}
 
	{
		Foo<void> foo;
		foo.run();
	}	
}
 
 

C++ (Qt)
virtual void run(AWebAbstractArguments*) = 0;

C++ (Qt)
template<class Result>
Result operator()() {
   AWebDelegateArguments<> args;
   return _container->run(&args);
}

C++ (Qt)
delegate.connect(&b, &Base::problemFunc);
int a = delegate.run<int>();

C++ (Qt)
delegate.connect<int>(&b, &Base::problemFunc);
int a = delegate();

C++ (Qt)
delegate.connect(&b, &Base::problemFunc);
int a = delegate.run<int>();

C++ (Qt)
// ClassA
virtual ClassA & run( void );
 
// ClassB
virtual ClassB & run( void );
 

C++ (Qt)
class Base
{
public:
   virtual operator int() {return 1;}
};
 
class Child : public Base
{
public:    
   virtual operator int() {return 2;}
};
 
Child child;
Base &base = child;
int i = base; //переменная i будет содержать значение "2"
 

C++ (Qt)
class AWebAbstractResult
{
public:
   virtual ~AWebAbstractResult() {}
 
   //Как объявить operator, исходя из данных нижеследующего класса.
   //virtual operator ???() = 0;
};
 
template<class Result>
class AWebDelegateResult : public AWebAbstractResult
{
public:
   AWebDelegateResult(Result data) : _data(data) {}
   virtual ~AWebDelegateResult() {}
 
   operator Result() {return _data;}
 
private:
    Result _data;
};
 

C++ (Qt)
#include <iostream>
#include <functional>
 
using namespace std;
 
class Base
{
public:
   virtual int operator()() {return 1;}
};
 
class Child : public Base
{
public:    
   virtual int operator()() {return 2;}
};
 
 int main()
 {
    function<int(Base&)> f_int = &Base::operator();
 
    Child ch;
    cout<<f_int(ch)<<std::endl;
 
    Base bs;
    cout<<f_int(bs)<<std::endl;
    return 0;
 }
 

C++ (Qt)
class Base
{
public:
   //Как объявить operator, исходя из данных нижеследующего класса.
   //virtual operator ???() = 0;
};
 
template<class Result>
class Child : public Base
{
public:
   Child(Result data) : _data(data) {}
   operator Result() {return _data;}
 
private:
    Result _data;
};
 

C++ (Qt)
#include "adelegate.h"
 
class A {
public:
    void echo() {qDebug() << "A::echo()";}
};
 
class Base {
public:
    void foo() {qDebug() << "foo()";}
    void bar(int a) {qDebug() << QString("bar(%1)").arg(a);}
 
    A *test(QString a, int b) {qDebug() << QString("test(%1)").arg(a) << b; return new A;}
 
};
 
int main(int argc, char *argv[])
{
Base b;
 
typedef void(Base::*foo)();
ADelegate<Base*, foo> delegate(&b, &Base::foo);
delegate();
 
typedef void(Base::*bar)(int);
ADelegate<Base*, bar, void, ALoki::TypeSequence<int> > delegate1(&b, &Base::bar);
delegate1(2);
 
typedef A*(Base::*test)(QString, int);
ADelegate<Base*, test, A*, ALoki::TypeSequence<QString, int> > delegate2(&b, &Base::test);
A *r = delegate2(QString("tratata"), 10);
r->echo();
delete r;
 
return 0;
}
 

C++ (Qt)
#include "alokifunctor.h"
 
void a() {
    qDebug() << "a()";
}
 
class Base {
public:
    const QString test(const QString &txt) {return txt;}
};
 
int main(int, char**)
{
ALoki::Functor<> functor(&a);
functor();
 
Base obj;
typedef const QString(Base::*test)(const QString&);
ALoki::Functor<const QString, ALoki::TypeSequence<const QString&> > functor1(&obj, &Base::test);
qDebug() << functor1("tratata");
 
return 0;
}
 

C++ (Qt)
#include <iostream>
#include <string>
#include "signal_slot.h"
 
void a() {
    std::cout << "a()" << std::endl;
}
 
class Base : public ssc::trackable {
public:
    void test1() {std::cout << "test1()";}
    void test2(int a) {std::cout << a << std::endl;}
    void test3(const std::string &b) {std::cout << b << std::endl;}
 
    int problemFunc() {
        std::cout << "We are the champions!!!" << std::endl;
        return 0;
    }
 
};
 
int main()
{
    ssc::signal<void> sig0;
    sig0.connect(a);
    sig0();
 
    Base base;
 
    ssc::signal<int> sig_int;
    sig_int.connect(&base, &Base::test2);
    sig_int(10);
 
    ssc::signal<void> sig_problemFunc;
    sig_problemFunc.connect(&base, &Base::problemFunc);
    sig_problemFunc();
 
 
    return 0;
}
 

C++ (Qt)
#include "alokifunctor.h"
 
void a() {
    qDebug() << "a()";
}
 
class Base {
public:
    const QString test(const QString &txt) {return txt;}
};
 
int main(int, char**)
{
ALoki::Functor<> functor(&a);
functor();
 
Base *obj = new Base;
typedef const QString(Base::*test)(const QString&);
ALoki::Functor<const QString, ALoki::TypeSequence<const QString&> > functor1(obj, &Base::test);
 
delete obj;
 
qDebug() << functor1("tratata");
 
qDebug() << obj->test("is not deleted!!!");
 
return 0;
}