default-parameters

Possible Duplicate: Implementing a no-op std::ostream Is there any stream equivalent of NULL in c++? I want to write a function that takes in a stream if the user wants to have the internal outputted to somewhere, but if not, the output goes into some fake place void data(std::stream & stream = fake_stream){ stream << "DATA" ; } i want to be able to chose to do data() or data(std::cout) Edit : Taken from @Johannes Schaub - litb's mail here with slight modifications: template<typename Ch, typename Traits = std::char_traits<Ch> > struct basic_nullbuf : std::basic_streambuf<Ch, Traits> { typedef

I'd like to use a default parameter value of IntPtr.Zero in a function that takes an IntPtr as an argument. This is not possible as IntPtr.Zero is not a compile time constant. Is there any way I can do what I want? Somewhat unintuitive, to put it mildly, you get it by using the new operator: void Foo(IntPtr arg = new IntPtr()) { } That was for fun, you probably enjoy this one better: void Foo(IntPtr arg = default(IntPtr)) { } Since IntPtr is a struct, you could use Nullable-of-T? static void SomeMethod(IntPtr? ptr = null) { var actualPtr = ptr ?? IntPtr.Zero; //... } 来源： https://stackoverflow

Please explain to me why the following piece of code complies and works perfectly. I am very confused. #include<iostream> template<class A = int, class B=double> class Base {}; template<class B> class Base <int, B> { public: Base() { std::cout<<"it works!!!!!\n"; } }; int main() { Base<> base; // it prints "it works!!!!!" return 0; } Shouldn't it fall into the generalized form of the template class Base? The default argument applies to the specialization -- and, in fact, a specialization must accept (so to speak) the base template's default argument(s). Attempting to specify a default in the

Possible Duplicate: default value of parameter as result of instance method While it is possible to set default values to function parameters in python: def my_function(param_one='default') ... It seems not to be possible to access the current instance (self): class MyClass(..): def my_function(self, param_one=self.one_of_the_vars): ... My question(s): Is this true that I cannot access the current instance to set the default parameter in functions? If it is not possble: what are the reasons and is it imaginable that this will be possible in future versions of python? It's written as: def my

PHP 5 Type Hinting PHP 5 introduces Type Hinting. Functions are now able to force parameters to be objects ( by specifying the name of the class in the function prototype ) or arrays ( since PHP 5.1 ). However, if NULL is used as the default parameter value, it will be allowed as an argument for any later call. The following excerpt from the above: if NULL is used as the default parameter value, it will be allowed as an argument for any later call. Does the above mean: if default parameters are to used use with type hinting, it can have only have NULL as the default value. i.e. the code in