diff options
author | Murray Cumming <murrayc@murrayc.com> | 2016-01-08 10:06:39 +0100 |
---|---|---|
committer | Murray Cumming <murrayc@murrayc.com> | 2016-03-07 10:42:42 +0100 |
commit | e7fb7d1f67cefc95a128b81243a1a39d9d20b02d (patch) | |
tree | e4b78b66dd587bc2b2840bd8a4486203d74760a4 | |
parent | 5553dea076d1a14809a5aee68b6b810976497a42 (diff) | |
download | sigc++-e7fb7d1f67cefc95a128b81243a1a39d9d20b02d.tar.gz |
C++11: Replace sigc::ref() with std::ref().
It seems to be remarkably similar.
-rw-r--r-- | sigc++/adaptors/bound_argument.h | 15 | ||||
-rw-r--r-- | sigc++/adaptors/macros/bind.h.m4 | 6 | ||||
-rw-r--r-- | sigc++/reference_wrapper.h | 66 | ||||
-rw-r--r-- | sigc++/visit_each.h | 4 | ||||
-rw-r--r-- | tests/test_bind.cc | 7 | ||||
-rw-r--r-- | tests/test_bind_ref.cc | 7 | ||||
-rw-r--r-- | tests/test_bind_return.cc | 7 | ||||
-rw-r--r-- | tests/test_copy_invalid_slot.cc | 3 | ||||
-rw-r--r-- | tests/test_cpp11_lambda.cc | 29 | ||||
-rw-r--r-- | tests/test_functor_trait.cc | 7 | ||||
-rw-r--r-- | tests/test_limit_reference.cc | 5 | ||||
-rw-r--r-- | tests/test_track_obj.cc | 4 |
12 files changed, 53 insertions, 107 deletions
diff --git a/sigc++/adaptors/bound_argument.h b/sigc++/adaptors/bound_argument.h index 0579682..ee9b6aa 100644 --- a/sigc++/adaptors/bound_argument.h +++ b/sigc++/adaptors/bound_argument.h @@ -23,18 +23,17 @@ #include <sigc++/limit_reference.h> #include <sigc++/reference_wrapper.h> - namespace sigc { /** A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return()) argument. * - * If Foo is a wrapped reference to a class Bar (reference_wrapper<Bar>) then this + * If Foo is a wrapped reference to a class Bar (std::reference_wrapper<Bar>) then this * object is implemented on top of a limit_reference. When the slot is * invoked, the limit_reference::invoke() method provides the argument (a Bar&). * When the slot is visited (e.g. visit_each<>()), we simply visit the limit_reference, * which will visit the derived type, or a sigc::trackable base if necessary. * - * Likewise, If Foo is a wrapped const reference to a class Bar (const_reference_wrapper<Bar>) + * Likewise, If Foo is a wrapped const reference to a class Bar (std::reference_wrapper<const Bar>) * then this object is implemented on top of a const_limit_reference. * * If Foo is something else (such as an argument that is bound by value) bound_argument just @@ -77,17 +76,17 @@ private: //Template specialization: /** bound_argument object for a bound argument that is passed by bind() or - * returned by bind_return() by reference, specialized for reference_wrapper<> types. + * returned by bind_return() by reference, specialized for std::reference_wrapper<> types. * @e T_wrapped The type of the bound argument. */ template <class T_wrapped> -class bound_argument< reference_wrapper<T_wrapped> > +class bound_argument< std::reference_wrapper<T_wrapped> > { public: /** Constructor. * @param _A_argument The argument to bind. */ - bound_argument(const reference_wrapper<T_wrapped>& _A_argument) + bound_argument(const std::reference_wrapper<T_wrapped>& _A_argument) : visited_(unwrap(_A_argument)) {} @@ -114,13 +113,13 @@ private: * - @e T_wrapped The type of the bound argument. */ template <class T_wrapped> -class bound_argument< const_reference_wrapper<T_wrapped> > +class bound_argument< std::reference_wrapper<const T_wrapped> > { public: /** Constructor. * @param _A_argument The argument to bind. */ - bound_argument(const const_reference_wrapper<T_wrapped>& _A_argument) + bound_argument(const std::reference_wrapper<const T_wrapped>& _A_argument) : visited_(unwrap(_A_argument)) {} diff --git a/sigc++/adaptors/macros/bind.h.m4 b/sigc++/adaptors/macros/bind.h.m4 index c008f46..367a3c0 100644 --- a/sigc++/adaptors/macros/bind.h.m4 +++ b/sigc++/adaptors/macros/bind.h.m4 @@ -320,14 +320,14 @@ struct count_void<void,void,void,void,void,void,void> * @endcode * * You can bind references to functors by passing the objects through - * the sigc::ref() helper function. + * the std::ref() helper function. * * @par Example: * @code * int some_int; * sigc::signal<void> some_signal; * void foo(int&); - * some_signal.connect(sigc::bind(&foo,sigc::ref(some_int))); + * some_signal.connect(sigc::bind(&foo, std::ref(some_int))); * @endcode * * If you bind an object of a sigc::trackable derived type to a functor @@ -339,7 +339,7 @@ struct count_void<void,void,void,void,void,void,void> * struct bar : public sigc::trackable {} some_bar; * sigc::signal<void> some_signal; * void foo(bar&); - * some_signal.connect(sigc::bind(&foo,sigc::ref(some_bar))); + * some_signal.connect(sigc::bind(&foo, std::ref(some_bar))); * // disconnected automatically if some_bar goes out of scope * @endcode * diff --git a/sigc++/reference_wrapper.h b/sigc++/reference_wrapper.h index 5a57e91..99b072f 100644 --- a/sigc++/reference_wrapper.h +++ b/sigc++/reference_wrapper.h @@ -21,64 +21,6 @@ namespace sigc { -/** Reference wrapper. - * Use sigc::ref() to create a reference wrapper. - */ -template <class T_type> -struct reference_wrapper -{ - explicit reference_wrapper(T_type& v) - : value_(v) {} - - operator T_type& () const - { return value_; } - - T_type& value_; -}; - -/** Const reference wrapper. - * Use sigc::ref() to create a const reference wrapper. - */ -template <class T_type> -struct const_reference_wrapper -{ - explicit const_reference_wrapper(const T_type& v) - : value_(v) {} - - operator const T_type& () const - { return value_; } - - const T_type& value_; -}; - -/** Creates a reference wrapper. - * Passing an object throught sigc::ref() makes libsigc++ adaptors - * like, e.g., sigc::bind store references to the object instead of copies. - * If the object type inherits from sigc::trackable this will ensure - * automatic invalidation of the adaptors when the object is deleted - * or overwritten. - * - * @param v Reference to store. - * @return A reference wrapper. - */ -template <class T_type> -reference_wrapper<T_type> ref(T_type& v) -{ return reference_wrapper<T_type>(v); } - -/** Creates a const reference wrapper. - * Passing an object throught sigc::ref() makes libsigc++ adaptors - * like, e.g., sigc::bind store references to the object instead of copies. - * If the object type inherits from sigc::trackable this will ensure - * automatic invalidation of the adaptors when the object is deleted - * or overwritten. - * - * @param v Reference to store. - * @return A reference wrapper. - */ -template <class T_type> -const_reference_wrapper<T_type> ref(const T_type& v) -{ return const_reference_wrapper<T_type>(v); } - template <class T_type> struct unwrap_reference { @@ -86,23 +28,23 @@ struct unwrap_reference }; template <class T_type> -struct unwrap_reference<reference_wrapper<T_type> > +struct unwrap_reference<std::reference_wrapper<T_type> > { typedef T_type& type; }; template <class T_type> -struct unwrap_reference<const_reference_wrapper<T_type> > +struct unwrap_reference<std::reference_wrapper<const T_type> > { typedef const T_type& type; }; template <class T_type> -T_type& unwrap(const reference_wrapper<T_type>& v) +T_type& unwrap(const std::reference_wrapper<T_type>& v) { return v; } template <class T_type> -const T_type& unwrap(const const_reference_wrapper<T_type>& v) +const T_type& unwrap(const std::reference_wrapper<const T_type>& v) { return v; } } /* namespace sigc */ diff --git a/sigc++/visit_each.h b/sigc++/visit_each.h index 82f4236..ab681cb 100644 --- a/sigc++/visit_each.h +++ b/sigc++/visit_each.h @@ -181,12 +181,12 @@ void visit_each_type(const T_action& _A_action, const T_functor& _A_functor) type_limited_action limited_action(_A_action); - //specifying the types of the template specialization prevents disconnection of bound trackable references (such as with sigc::ref()), + //specifying the types of the template specialization prevents disconnection of bound trackable references (such as with std::ref()), //probably because the visit_each<> specializations take various different template types, //in various sequences, and we are probably specifying only a subset of them with this. // //But this is required by the AIX (and maybe IRIX MipsPro and Tru64) compilers. - //I guess that sigc::ref() therefore does not work on those platforms. murrayc + //I guess that std::ref() therefore does not work on those platforms. murrayc // sigc::visit_each<type_limited_action, T_functor>(limited_action, _A_functor); //g++ (even slightly old ones) is our primary platform, so we could use the non-crashing version. diff --git a/tests/test_bind.cc b/tests/test_bind.cc index 845d54c..3ab7cf6 100644 --- a/tests/test_bind.cc +++ b/tests/test_bind.cc @@ -8,6 +8,7 @@ #include <sigc++/functors/slot.h> #include <sstream> #include <string> +#include <functional> //For std::ref(). #include <cstdlib> namespace @@ -130,7 +131,7 @@ int main(int argc, char* argv[]) // method pointer instead of functor book test_book("otto"); - result_stream << sigc::bind<0>(&book::get_name, sigc::ref(test_book))(); + result_stream << sigc::bind<0>(&book::get_name, std::ref(test_book))(); util->check_result(result_stream, "otto"); // test return type of bind_functor::operator() overload with no arguments @@ -142,14 +143,14 @@ int main(int argc, char* argv[]) // test references std::string str("guest book"); - sigc::bind(&egon, sigc::ref(str))(); // Tell bind that it shall store a reference. + sigc::bind(&egon, std::ref(str))(); // Tell bind that it shall store a reference. result_stream << " " << str; // (This cannot be the default behaviour: just think about what happens if str dies!) util->check_result(result_stream, "egon(string 'guest book') egon was here"); sigc::slot<void> sl; { book guest_book("karl"); - sl = sigc::bind(&egon, sigc::ref(guest_book)); + sl = sigc::bind(&egon, std::ref(guest_book)); sl(); result_stream << " " << static_cast<std::string&>(guest_book); util->check_result(result_stream, "egon(string 'karl') egon was here"); diff --git a/tests/test_bind_ref.cc b/tests/test_bind_ref.cc index 58bd55d..d8ea53b 100644 --- a/tests/test_bind_ref.cc +++ b/tests/test_bind_ref.cc @@ -2,6 +2,7 @@ #include <sigc++/sigc++.h> #include <sstream> #include <string> +#include <functional> //For std::ref(). #include <cstdlib> namespace @@ -48,12 +49,12 @@ int main(int argc, char* argv[]) util->check_result(result_stream, ""); { - //Because Param derives from sigc::trackable(), sigc::ref() should disconnect + //Because Param derives from sigc::trackable(), std::ref() should disconnect // the signal handler when param is destroyed. Param param("murrayc"); // A convoluted way to do - // slot_bound = sigc::bind(slot_full, sigc::ref(param)); - slot_bound = sigc::bind< -1, sigc::reference_wrapper<Param> >(slot_full, sigc::ref(param)); + // slot_bound = sigc::bind(slot_full, std::ref(param)); + slot_bound = sigc::bind< -1, std::reference_wrapper<Param> >(slot_full, std::ref(param)); result_stream << "Calling slot when param exists:"; slot_bound(); diff --git a/tests/test_bind_return.cc b/tests/test_bind_return.cc index 88c85ae..232f402 100644 --- a/tests/test_bind_return.cc +++ b/tests/test_bind_return.cc @@ -8,6 +8,7 @@ #include <sigc++/functors/slot.h> #include <sstream> #include <string> +#include <functional> //For std::ref(). #include <cstdlib> namespace @@ -52,8 +53,8 @@ int main(int argc, char* argv[]) // references. std::string str("guest book"); // A convoluted way to do - // sigc::bind_return(foo(), sigc::ref(str))(6) = "main"; - sigc::bind_return<sigc::reference_wrapper<std::string> >(foo(), sigc::ref(str))(6) = "main"; + // sigc::bind_return(foo(), std::ref(str))(6) = "main"; + sigc::bind_return<std::reference_wrapper<std::string> >(foo(), std::ref(str))(6) = "main"; result_stream << str; util->check_result(result_stream, "foo(int 6) main"); @@ -67,7 +68,7 @@ int main(int argc, char* argv[]) sigc::slot<bar, int> sl; { bar choco(-1); - sl = sigc::bind_return(foo(),sigc::ref(choco)); + sl = sigc::bind_return(foo(), std::ref(choco)); result_stream << sl(7); util->check_result(result_stream, "foo(int 7) -1"); } // auto-disconnect diff --git a/tests/test_copy_invalid_slot.cc b/tests/test_copy_invalid_slot.cc index b480a15..a6179c3 100644 --- a/tests/test_copy_invalid_slot.cc +++ b/tests/test_copy_invalid_slot.cc @@ -4,6 +4,7 @@ #include <sigc++/sigc++.h> #include <stdlib.h> #include <string.h> +#include <functional> //For std::ref(). namespace { @@ -30,7 +31,7 @@ int main(int argc, char* argv[]) util->check_result(result_stream, "sigc::trackable instance at " + pointer_stream.str()); pointer_stream.str(""); - sigc::slot<void> foo = sigc::bind(sigc::ptr_fun(Foo), sigc::ref(*t)); + sigc::slot<void> foo = sigc::bind(sigc::ptr_fun(Foo), std::ref(*t)); foo(); util->check_result(result_stream, "Foo(x)"); diff --git a/tests/test_cpp11_lambda.cc b/tests/test_cpp11_lambda.cc index e97b80e..5532f26 100644 --- a/tests/test_cpp11_lambda.cc +++ b/tests/test_cpp11_lambda.cc @@ -51,7 +51,6 @@ #include <cstdlib> #include <sigc++/functors/functors.h> #include <sigc++/bind.h> -#include <sigc++/reference_wrapper.h> #include <sigc++/adaptors/track_obj.h> #include <sigc++/signal.h> @@ -182,9 +181,9 @@ int main(int argc, char* argv[]) result_stream << ([] (int x) -> int { return ++x * 2; }(a_outer)) << " " << a_outer; util->check_result(result_stream, "4 1"); - // gcc can't compile libsigc++ lambda expressions with sigc::ref() parameters. + // gcc can't compile libsigc++ lambda expressions with std::ref() parameters. // See https://bugzilla.gnome.org/show_bug.cgi?id=669128 - // std::cout << "((++_1)*2)(ref(a)): " << ((++_1)*2)(sigc::ref(a)); + // std::cout << "((++_1)*2)(ref(a)): " << ((++_1)*2)(std::ref(a)); // std::cout << "; a: " << a << std::endl; result_stream << ([] (std::reference_wrapper<int> x) -> int { return ++x * 2; }(std::ref(a_outer))); result_stream << " " << a_outer; @@ -199,7 +198,7 @@ int main(int argc, char* argv[]) result_stream << " " << a_outer; util->check_result(result_stream, "8 4"); - // std::cout << "((--(*(&_1)))*2)(ref(a)): " << ((--(*(&_1)))*2)(sigc::ref(a)); + // std::cout << "((--(*(&_1)))*2)(ref(a)): " << ((--(*(&_1)))*2)(std::ref(a)); // std::cout << "; a: " << a << std::endl; result_stream << ([] (std::reference_wrapper<int> x) -> int { return --(*(&x)) * 2; }(std::ref(a_outer))); result_stream << " " << a_outer; @@ -241,15 +240,15 @@ int main(int argc, char* argv[]) // - var() is used to create a lambda that holds a reference and is interchangable with ref() in lambda operator expressions // - cannot use std::endl without much hackery because it is defined as a template function // - cannot use "\n" without var() because arrays cannot be copied - // (sigc::ref(std::cout) << sigc::constant(1) << sigc::var("\n"))(); + // (std::ref(std::cout) << sigc::constant(1) << sigc::var("\n"))(); [](){ result_stream << 1 << "\n"; }(); util->check_result(result_stream, "1\n"); - //(sigc::ref(std::cout) << _1 << std::string("\n"))("hello world"); + //(std::ref(std::cout) << _1 << std::string("\n"))("hello world"); [](const char* a){ result_stream << a << std::string("\n"); }("hello world"); util->check_result(result_stream, "hello world\n"); - //(sigc::ref(std::cout) << sigc::static_cast_<int>(_1) << std::string("\n"))(1.234); + //(std::ref(std::cout) << sigc::static_cast_<int>(_1) << std::string("\n"))(1.234); [](double a){ result_stream << static_cast<int>(a) << std::string("\n"); }(1.234); util->check_result(result_stream, "1\n"); @@ -269,7 +268,7 @@ int main(int argc, char* argv[]) sigc::slot<void, std::ostringstream&> sl1; { book guest_book("karl"); - //sl1 = (sigc::var(std::cout) << sigc::ref(guest_book) << sigc::var("\n")); + //sl1 = (sigc::var(std::cout) << std::ref(guest_book) << sigc::var("\n")); // sl1 = [&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }; // no auto-disconnect sl1 = sigc::track_obj([&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }, guest_book); sl1(result_stream); @@ -290,7 +289,7 @@ int main(int argc, char* argv[]) result_stream << std::bind(&foo, std::placeholders::_2, std::placeholders::_1)(1, 2); util->check_result(result_stream, "foo(int 2, int 1) 9"); - //std::cout << (sigc::group(sigc::mem_fun(&bar::test), _1, _2, _3)) (sigc::ref(the_bar), 1, 2) << std::endl; + //std::cout << (sigc::group(sigc::mem_fun(&bar::test), _1, _2, _3)) (std::ref(the_bar), 1, 2) << std::endl; // std::ref(the_bar) is not necessary. It can make the call ambiguous. // Even without std::ref() the_bar is not copied. result_stream << std::bind(std::mem_fn(&bar::test), std::placeholders::_1, @@ -320,7 +319,7 @@ int main(int argc, char* argv[]) sigc::slot<void> sl2; { book guest_book("karl"); - //sl2 = sigc::group(&egon, sigc::ref(guest_book)); + //sl2 = sigc::group(&egon, std::ref(guest_book)); // sl2 = [&guest_book] () { egon(guest_book); }; // no auto-disconnect // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) sl2 = sigc::track_obj([&guest_book] () { egon(guest_book); }, guest_book); @@ -339,7 +338,7 @@ int main(int argc, char* argv[]) // More auto-disconnect { book guest_book("charlie"); - //sl2 = sigc::group(&egon, sigc::ref(guest_book)); + //sl2 = sigc::group(&egon, std::ref(guest_book)); // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) auto fn2 = std::bind(&egon, std::ref(guest_book)); //sl2 = fn2; // no auto-disconnect @@ -469,9 +468,9 @@ int main(int argc, char* argv[]) { int some_int = 0; sigc::signal<void> some_signal; - //some_signal.connect(sigc::group(&foo,sigc::ref(some_int))); + //some_signal.connect(sigc::group(&foo,std::ref(some_int))); //some_signal.connect(std::bind(&foo_group3, std::ref(some_int))); // does not compile (gcc 4.6.3) - //some_signal.connect(sigc::bind(&foo_group3, sigc::ref(some_int))); // compiles, but we prefer std::bind() or C++11 lambda + //some_signal.connect(sigc::bind(&foo_group3, std::ref(some_int))); // compiles, but we prefer std::bind() or C++11 lambda some_signal.connect([&some_int](){ foo_group3(some_int); }); some_signal.emit(); result_stream << " " << some_int; @@ -483,10 +482,10 @@ int main(int argc, char* argv[]) sigc::signal<void> some_signal; { bar_group4 some_bar; - //some_signal.connect(sigc::group(&foo,sigc::ref(some_bar))); + //some_signal.connect(sigc::group(&foo, std::ref(some_bar))); // disconnected automatically if some_bar goes out of scope //some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect - //some_signal.connect(sigc::bind(&foo_group4, sigc::ref(some_bar))); // auto-disconnects, but we prefer C++11 lambda + //some_signal.connect(sigc::bind(&foo_group4, std::ref(some_bar))); // auto-disconnects, but we prefer C++11 lambda some_signal.connect(sigc::track_obj([&some_bar](){ foo_group4(some_bar); }, some_bar)); some_signal.emit(); util->check_result(result_stream, "foo_group4(bar_group4&)"); diff --git a/tests/test_functor_trait.cc b/tests/test_functor_trait.cc index 1031845..c14a126 100644 --- a/tests/test_functor_trait.cc +++ b/tests/test_functor_trait.cc @@ -4,6 +4,7 @@ #include "testutilities.h" #include <sstream> +#include <functional> //For std::ref(). #include <cstdlib> #include <sigc++/adaptors/bind.h> #include <sigc++/adaptors/compose.h> @@ -83,15 +84,15 @@ int main(int argc, char* argv[]) int k = 3; A a; result_stream << "hit all targets: "; - sigc::visit_each(print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), sigc::ref(a), i), sigc::ptr_fun(&bar))); + sigc::visit_each(print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), std::ref(a), i), sigc::ptr_fun(&bar))); util->check_result(result_stream, "hit all targets: other trackable int: 1 other "); result_stream << "hit all ints: "; - sigc::visit_each_type<int>(print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), sigc::ref(a), j),sigc::ptr_fun(&bar))); + sigc::visit_each_type<int>(print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), std::ref(a), j),sigc::ptr_fun(&bar))); util->check_result(result_stream, "hit all ints: int: 2 "); result_stream << "hit all trackable: "; - sigc::visit_each_type<trackable>(print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), sigc::ref(a), k),sigc::ptr_fun(&bar))); + sigc::visit_each_type<trackable>(print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), std::ref(a), k),sigc::ptr_fun(&bar))); util->check_result(result_stream, "hit all trackable: trackable "); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; diff --git a/tests/test_limit_reference.cc b/tests/test_limit_reference.cc index d72efd1..34fa547 100644 --- a/tests/test_limit_reference.cc +++ b/tests/test_limit_reference.cc @@ -1,6 +1,7 @@ #include "testutilities.h" #include <sigc++/sigc++.h> #include <sstream> +#include <functional> //For std::ref(). #include <cstdlib> namespace @@ -45,12 +46,12 @@ int main(int argc, char* argv[]) util->check_result(result_stream, "method()"); auto param = - sigc::bind(sigc::slot<void, Derived&>(), sigc::ref(*instance)); + sigc::bind(sigc::slot<void, Derived&>(), std::ref(*instance)); param(); util->check_result(result_stream, ""); auto ret = - sigc::bind_return(sigc::slot<void>(), sigc::ref(*instance)); + sigc::bind_return(sigc::slot<void>(), std::ref(*instance)); ret(); util->check_result(result_stream, ""); diff --git a/tests/test_track_obj.cc b/tests/test_track_obj.cc index a6ce6ed..635be0c 100644 --- a/tests/test_track_obj.cc +++ b/tests/test_track_obj.cc @@ -202,10 +202,10 @@ int main(int argc, char* argv[]) sigc::signal<void> some_signal; { bar_group4 some_bar; - //some_signal.connect(sigc::group(&foo,sigc::ref(some_bar))); + //some_signal.connect(sigc::group(&foo, std::ref(some_bar))); // disconnected automatically if some_bar goes out of scope //some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect - //some_signal.connect(sigc::bind(&foo_group4, sigc::ref(some_bar))); // auto-disconnects, but we prefer C++11 lambda + //some_signal.connect(sigc::bind(&foo_group4, std::ref(some_bar))); // auto-disconnects, but we prefer C++11 lambda some_signal.connect(sigc::track_obj([&some_bar](){ foo_group4(some_bar); }, some_bar)); some_signal.emit(); util->check_result(result_stream, "foo_group4(bar_group4&)"); |