overloading

I was just reading the Wikipedia article on C11 , the new version of the C standard released in Dec 2011, and I saw that one of the added features was "type-generic expressions": Type-generic expressions using the _Generic keyword. For example, the following macro cbrt(x) translates to cbrtl(x) , cbrt(x) or cbrtf(x) depending on the type of x : #define cbrt(X) _Generic((X), long double: cbrtl, \ default: cbrt, \ float: cbrtf)(X) This looks pretty horrible to me - if they are going to change the language anyways, why not just add function overloading like in C++? Potatoswatter C has one

How to pick the correct error() member function? Do I need to cast somehow? using namespace std; struct test { int error(); void error(int x); int fun(); }; int main() { auto f1 = &test::error; // how to pick the correct function? auto f2 = &test::fun; // works } Do I need to cast somehow? Yes, you can use static_cast . static_cast may also be used to disambiguate function overloads by performing a function-to-pointer conversion to specific type, as in std::transform(s.begin(), s.end(), s.begin(), static_cast<int(*)(int)>(std::toupper)); So you can: auto f1 = static_cast<int(test::*)()>(&test:

I am using an cookbook github.com opscode-cookbooks/openldap. I wrote an wrapper cookbook "lab_openldap" that includes "openldap::server" recipe. The server.rb recipe uses following clausule to upload the PEM file from cookbooks files/ssl/*.pem to server to the location node['openldap']['ssl_cert']. if node['openldap']['tls_enabled'] && node['openldap']['manage_ssl'] cookbook_file node['openldap']['ssl_cert'] do source "ssl/#{node['openldap']['server']}.pem" mode 00644 owner "root" group "root" end end The PEM is tried to be read from "openldap" cookbook file/ssl/#{node['openldap']['server']}

#include<iostream> using namespace std; class complex { double real; double image; public: complex(double r=0,double i=0) : real(r), image(i) { }; complex(const complex& c) : real(c.real), image(c.image) { }; ~complex(){}; double re() const { return real; }; double im() const{ return image; }; const complex& operator =(const complex&c) { real = c.real; image = c.image; return *this; }; const complex& operator +=(const complex&c) { real += c.real; image += c.image; return *this; }; const complex& operator -=(const complex&c) { real -= c.real; image -= c.image; return *this; }; const complex&

I want to create proxies for member functions and operators. They must have the same return type and parameters, and must be good for several classes, which are given as template parameters. Even if the class does not have the particular member function or operator, I want it to compile instead of failing with an error, essentially SFINAE. If X has a method f() and Y does not have any method named f , I need Proxy<X> to have an f() as well that calls X::f() , and I need Proxy<Y> to compile and instantiate without any problems. Extracting the return type from a known function is no longer a

lazy val productService = BeanLookup[ProductDataService] object BeanLookup { def apply[T](implicit manifest: Manifest[T], context: ActorContext) = { val beanLookup = context.actorFor("/user/spring/beanLookup") Await.result( (beanLookup.ask(LookupBean(manifest.erasure))(timeout)).mapTo[T](manifest), timeout.duration) } def apply[T](implicit manifest: Manifest[T], system: ActorSystem) = { val beanLookup = system.actorFor("/user/spring/beanLookup") Await.result( (beanLookup.ask(LookupBean(manifest.erasure))(timeout)).mapTo[T](manifest), timeout.duration) } } scalac complains : scala: ambiguous