나는 한 팔이 없는 장애인이지만 세상에 멀쩡한 몸을 가진 정신적인 장애인이 얼마나 많은가 - 김선기 설봉체육관 관장 미디어 다음 인터뷰에서. 한쪽 팔이 없는 불구의 몸으로 무에타이 격투기 현역을 뛰는 자신을 얘기하며.

Morphix
curl �̾߱�
libevent
polygon soup

sigcppƩ�丮��

* 원문링크 : [http]

http://libsigc.sourceforge.net/libsigc1_2/manual/html/

1 소개

1.1 제작동기

2 코드에 신호(signal)을 연결시키기

2.1 간단한 예제
2.2 맴버함수를 사용하기
2.3 매개변수를 가진 신호
2.4 연결해제

3 자신만의 신호(signal)을 작성하기

3.1 빨리 모자를 바꿔쓰기(recap)
3.2 반환값이 뭐지?

4 좀 어려운 주제들

4.1 다시 bind 하기
4.2 타입 재지정하기
4.3 마샬러(marshaller)

[edit]

1 소개 #

[edit]

1.1 제작동기 #

There are many situations in which it is desirable to decouple code that detects an event, and the code that deals with it. This is especially common in GUI programming, where a toolkit might provide user interface elements such as clickable buttons but, being a generic toolkit, doesn't know how an individual application using that toolkit should handle the user clicking on it.

C언어에서 콜백은 일반적으로 어플리케이션이 함수 포인터와 void * 매개변수를 가진 '등록' 함수를 호출함으로서 다루어지게 됩니다. 예를 들면 다음과 같겠죠.

void clicked(void *data);

button * okbutton = create_button("ok");
static char somedata[] = "This is some data I want the clicked() function to have";

register_click_handler(okbutton, clicked, somedata);

클릭되면, 툴킷은 register_click_handler() 함수에 전달된 data 포인터값을 사용하여 clicked()을 호출하게 될 것입니다.

이것은 C에서 동작하긴 하지만, 타입안전성을 보장해주지 않습니다. 다시말하자면 cliecked()에는 char *말고 다른 형태의 구조체 포인터를 넣지 않는다는 것을 컴파일시점에서 보장해주지 않습니다.

C++ 프로그래머의 입장에서는 타입안전성을 당연히 원하게 됩니다. 또한 콜백으로서 자유롭게 독립된 전역 함수보다는 다른 것을 사용하려고 할 것입니다.

libsigc++은 다음과 같은 콜백으로서 사용될 수 있는 대상들중 하나에 대한 참조를 담아두는 슬롯의 개념을 제공하고 있습니다.

예제안에서와 같은 독립 전역함수
연산자 ()를 오버로딩한 객체 포인터(함수자(functor))
맴버 변수 포인터와 이를 호출할 객체 인스턴스(객체는 SigC::Object로부터 상속받아야만 합니다)

이들 모두는 다양한 개수와 타입의 매개변수를 가질 수 있습니다.

이러한 작업들을 구축하기 쉽게 하기위해, slot이라고 불리는 오버로딩된 템플릿 클래스가 제공됩니다. slot은 매개변수(또는, 필요한 매개변수가 담겨져있는 곳)를 가지며 연산자()를 사용하여 호출가능한 일반 Slot 타입을 반환합니다.

반대의 개념으로, libsigc++은 신호(signal)을 제공하여, 클라이언트가 슬롯들을 접근할 수 있도록 합니다. 신호가 켜지면(emit), 모든 연결된 슬롯들은 역호출됩니다.

[edit]

2 코드에 신호(signal)을 연결시키기 #

[edit]

2.1 간단한 예제 #

The terminology for signals and slots has come under some criticism for not being as intuitive as it maybe could have been, but with a little experience it won't cause a problem. Honest.

So to get some experience, lets look at a simple example...

Lets say you and I are writing an application which informs the user when aliens land in the car park. To keep the design nice and clean, and allow for maximum portability to different interfaces, we decide to use LibSigC++ to split the project in two parts.

I will write the AlienDetector class, and you will write the code to inform the user. (Well, OK, I'll write both, but we're pretending, remember?)

Here's my class:

class AlienDetector
{
public:
    AlienDetector();

    void run();

    SigC::Signal0<void> detected;
};

(I'll explain the type of detected later.)

Here's your code that uses it:

void warn_people()
{
    cout << "There are aliens in the carpark!" << endl;
}

int main()
{
    AlienDetector mydetector;
    mydetector.detected.connect( SigC::slot(warn_people) );

    mydetector.run();

    return 0;
}

Pretty simple really - you call the connect() method on the signal to connect your function. connect() takes a slot parameter (remember slots are capable of holding any type of callback), so you convert your warn_people() function to a slot using the slot() function.

To compile this example from the downloadable example code, use:

g++ example1.cc -o eg1 `pkg-config --cflags --libs sigc++-1.2`Note that those `` characters are backticks, not single quotes. Run it with
./eg1(Try not to panic when the aliens land!)

[edit]

2.2 맴버함수를 사용하기 #

Suppose you found a more sophisticated alien alerter class on the web, such as this:

class AlienAlerter : public SigC::Object
{
public:
    AlienAlerter(char const* servername);
    void alert();
private:
    // ...
};

(Handily it derives from SigC::Object already. This isn't quite so unlikely as you might think; all appropriate bits of the popular gtkmm library do so, for example.)

You could rewrite your code as follows:

int main()
{
    AlienDetector mydetector;
    AlienAlerter  myalerter("localhost");	// added
    mydetector.detected.connect( SigC::slot(myalerter, &AlienAlerter::alert) ); // changed

    mydetector.run();

    return 0;
}

Note that only 2 lines are different - one to create an instance of the class, and the line to connect the method to the signal.

This code is in example2.cc, which can be compiled in the same way as example1.cc

[edit]

2.3 매개변수를 가진 신호 #

Functions taking no parameters and returning void are quite useful, especially when they're members of classes that can store unlimited amounts of safely typed data, but they're not sufficient for everything.

What if aliens don't land in the carpark, but somewhere else? Let's modify the example so that the callback function takes a std::string with the location in which aliens were detected.

I change my class to:

class AlienDetector
{
public:
    AlienDetector();

    void run();

    SigC::Signal1<void, std::string> detected;	// changed
};

The only line I had to change was the signal line (in run() I need to change my code to supply the argument when I emit the signal too, but that's not shown here).

The name of the type is 'SignalN', where N is the number of arguments that the slots should take. The template parameters are the return type, then the argument types.

libsigc++은 Signal 템플릿 매개변수의 수를 무한하게 정의하도록 하고 있지 않고, 명시적으로 Signal0에서 Signal5까지 정의하고 있으며 이정도라면 대부분의 사람들이 충분하다고 얘기하고 있습니다.(만약 M4 스크립트에 대해 지식이 있다면, 소스를 고쳐 필요한만큼 더 늘릴수도 있습니다)

The types in the function signature are in the same order as the template parameters, eg:

SigC::Signal1<void,         std::string>
              void function(std::string foo);

So now you can update your alerter (for simplicity, lets go back to the free-standing function version):

void warn_people(std::string where)
{
    cout << "There are aliens in " << where << "!" << endl;
}

int main()
{
    AlienDetector mydetector;
    mydetector.detected.connect( SigC::slot(warn_people) );

    mydetector.run();

    return 0;
}

Easy.

[edit]

2.4 연결해제 #

If you decide you no longer want your code to be called whenever a signal is emitted, you must remember the return value of connect(), which we've been ignoring until now.

connect() returns a SigC::Connection object, which has a member disconnect(). This does just what you think it does.

[edit]

3 자신만의 신호(signal)을 작성하기 #

[edit]

3.1 빨리 모자를 바꿔쓰기(recap) #

If all you want to do is use gtkmm, and connect your functionality to its signals, you can probably stop reading here.

You might benefit from reading on anyway though, as this section is going to be quite simple, and the 'Rebinding' technique from the next section is occasionally useful.

We've already covered the way the types of signals are made up, but lets recap:

A signal is an instance of a template, named SigC::SignalN where N is the number of arguments taken, 0-5. The template arguments are the types, in the order they appear in the function signature that can be connected to that signal; that is the return type, then the argument types.

To provide a signal for people to connect to, you must make available an instance of that SigC::Signal. In AlienDetector this was done with a public data member. That's not considered good practice usually, so you might want to consider making a member function that returns the signal by reference. (This is what gtkmm does.)

Once you've done this, all you have to do is emit the signal when you're ready. Look at the code for AlienDetector::run():

void AlienDetector::run()
{
    sleep(3); // wait for aliens
    detected.emit(); // panic!
}

As a shortcut, Signal defines operator() as a synonym for emit(), so you could just write detected(); as in the second example version:

void AlienDetector::run()
{
    sleep(3);                // wait for aliens
    detected("the carpark"); // this is the std::string version, looks like
       	                     // they landed in the carpark afterall.
}

[edit]

3.2 반환값이 뭐지? #

If you only ever have one slot connected to a signal, or if you only care about the return value of the last registered one, it's quite straightforward:

SigC::Signal0<int> somesignal;
int a_return_value;

a_return_value = somesignal();

If you care about every return value things are a little more complicated. See the section on Marshallers for more info.

[edit]

4 좀 어려운 주제들 #

[edit]

4.1 다시 bind 하기 #

Suppose you already have a function that you want to be called back when a signal is emitted, but it takes the wrong argument types. For example, lets try to attach the warn_people(std::string) function to the detected signal from the first example, which didn't supply a location string.

Just trying to connect it with:

myaliendetector.detected.connect(SigC::slot(warn_people));

results in a compile-time error, because the types don't match. This is good! This is typesafety at work. In the C way of doing things, this would have just died at runtime after trying to print a random bit of memory as the location - ick!

We have to make up a location string, and bind it to the function, so that when detected is emitted with no arguments, something adds it in before warn_people is actually called.

We could write it ourselves - it's not hard:

void warn_people_wrapper() // note this is the signature that 'detected' expects
{
    warn_people("the carpark");
}

but after our first million or so we might start looking for a better way. As it happens, LibSigC++ has one.

SigC::bind(slot, arg);

binds arg as the argument to slot, and returns a new slot of the same return type, but with one fewer arguments.

Now we can write:

myaliendetector.detected.connect(SigC::bind( SigC::slot(warn_people), "the carpark" ) );

If the input slot has multiple args, the rightmost one is bound.

The return type can also be bound with bind_return(slot, returnvalue); though this is not so commonly useful.

So if we can attach the new warn_people() to the old detector, can we attach the old warn_people (the one that didn't take an argument) to the new detector?

Of course, we just need to hide the extra argument. This can be done with SigC::hide, eg.

myaliendetector.detected.connect( SigC::hide<std::string>( SigC::slot(warn_people) ) );

The template arguments are the types to hide (from the right only - you can't hide the first argument of 3, for example, only the last).

hide_return effectively makes the return type void.

[edit]

4.2 타입 재지정하기 #

A similar topic is retyping. Perhaps you have a signal that takes an int, but you want to connect a function that takes a double.

This can be achieved with the retype template. retype has template arguments just like Signal - return value, signal types.

It's a function template that takes a slot, and returns a slot. eg.

void dostuff(double foo)
{
}

SigC::Signal1<void,int> asignal;

asignal.connect(  retype<void,int>( slot(&dostuff) )  );

If you only want to change the return type, you can use retype_return. retype_return needs only one template argument.

[edit]

4.3 마샬러(marshaller) #

When I first mentioned return values, I said that more advanced handling of multiple return values was possible with Marshallers.

A Marshaller is a class that gets fed all the return values as they're returned. It can do a couple of things:

It can stop the emit process at any point, causing no further slots to be called
It can return a value, of any type

For example, if each slot returned an int, we could use a marshaller return the average value as a double. Or we could return all values in a std::vector<int>, or maybe stop as soon as the first slot returns 5.

As an example, here's the averaging marshaller:

class Averager
{
public:
    // we must typedef InType and OutType for the SigC library
    typedef double OutType;
    typedef int InType;

    Averager()
      : total_(0), number_(0)
      {}


    OutType value() { return (double)total_/(double)number_; } // avoid integer division

    static OutType default_value() { return 0; }

    // This is the function called for each return value.
    // If it returns 'true' it stops here.
    bool marshal(InType newval)
    {
        total_ += newval; // total of values
        ++number_;        // count of values
        return false;     // continue emittion process
    };

private:
    int   total_;
    int   number_;
};

To use this, we pass the type as an extra template argument when defining the Signal, eg.

SigC::Signal0<int,Averager> mysignal;

Now we can do:

double average_of_all_connected_slots = mysignal();

Each connected slot will be called, its value passed to an instance of Averager and that Averager's value() will be returned.

In the downloadable examples, this is example6.cc.

ID
Password
Join

Contents

1 소개 #

1.1 제작동기 #

2 코드에 신호(signal)을 연결시키기 #

2.1 간단한 예제 #

2.2 맴버함수를 사용하기 #

2.3 매개변수를 가진 신호 #

2.4 연결해제 #

3 자신만의 신호(signal)을 작성하기 #

3.1 빨리 모자를 바꿔쓰기(recap) #

3.2 반환값이 뭐지? #

4 좀 어려운 주제들 #

4.1 다시 bind 하기 #

4.2 타입 재지정하기 #

4.3 마샬러(marshaller) #