Comments for cplusplus.co.il

Comment on Reference to temporary by Boris Batkin

Boris Batkin — Tue, 31 Jan 2012 01:36:14 +0000

It’s not virtual dispatching, since its temp object being destructed. And type of that temp object is known at compilation time. Think of it as if it was something in the lines of { B tmp = func(); const & A = tmp; }, only with the move semantics. Otherwise very good article.

Comment on Imitation of Java Generics by Andrzej Krzemieński

Andrzej Krzemieński — Fri, 30 Sep 2011 11:50:35 +0000

Hi,
I would like to add to your view of generics that apart from problems like clumsy interface (we require unnecessary inheritance) and some safety issues, they have obvious advantages over templates, at least when it comes to defining generic containers:
1. No cryptic error messages.
2. Much faster compilation – a generic can be compiled once, regardless of how many times you instantiate it and with how many types.
3. Smaller executable – each template instantiation generates almost the same code time and again – this is not so for generics

That said, I would also not like to see generics in C++. You can still implement something similar yourself using templates.

Regards,
&rzej

Comment on boost::optional and its internals by Iain Fraser

Iain Fraser — Wed, 14 Sep 2011 18:10:01 +0000

great article man

Comment on Reference to temporary by Андрей Кузнецов

Андрей Кузнецов — Fri, 01 Jul 2011 19:57:24 +0000

great article! very interesting point about how proper dctor is being called without virtual dispatching. Tnx

Comment on Variadic macro to count number of arguments by Andrea Zilio

Andrea Zilio — Fri, 29 Apr 2011 23:15:48 +0000

To support zero arguments:

#define VA_NUM_ARGS(…) VA_NUM_ARGS_IMPL(, ##__VA_ARGS__, 5,4,3,2,1,0)
#define VA_NUM_ARGS_IMPL(_0,_1,_2,_3,_4,_5,N,…) N

Comment on Variadic macro to count number of arguments by Paul Vercellotti

Paul Vercellotti — Fri, 15 Apr 2011 21:44:55 +0000

Here is an implementation that works for the zero-arguments case, incorporating Jens Gustedt’s very helpful workaround posted further up in the comments. It could use some simplification, but it works:

#define _ARG16(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, …) _15
#define HAS_COMMA(…) _ARG16(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0)
#define HAS_NO_COMMA(…) _ARG16(__VA_ARGS__, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
#define _TRIGGER_PARENTHESIS_(…) ,

#define HAS_ZERO_OR_ONE_ARGS(…) \
_HAS_ZERO_OR_ONE_ARGS( \
/* test if there is just one argument, eventually an empty \
one */ \
HAS_COMMA(__VA_ARGS__), \
/* test if _TRIGGER_PARENTHESIS_ together with the argument \
adds a comma */ \
HAS_COMMA(_TRIGGER_PARENTHESIS_ __VA_ARGS__), \
/* test if the argument together with a parenthesis \
adds a comma */ \
HAS_COMMA(__VA_ARGS__ (~)), \
/* test if placing it between _TRIGGER_PARENTHESIS_ and the \
parenthesis adds a comma */ \
HAS_COMMA(_TRIGGER_PARENTHESIS_ __VA_ARGS__ (~)) \
)

#define PASTE5(_0, _1, _2, _3, _4) _0 ## _1 ## _2 ## _3 ## _4
#define _HAS_ZERO_OR_ONE_ARGS(_0, _1, _2, _3) HAS_NO_COMMA(PASTE5(_IS_EMPTY_CASE_, _0, _1, _2, _3))
#define _IS_EMPTY_CASE_0001 ,

#define _VA0(…) HAS_ZERO_OR_ONE_ARGS(__VA_ARGS__)
#define _VA1(…) HAS_ZERO_OR_ONE_ARGS(__VA_ARGS__)
#define _VA2(…) 2
#define _VA3(…) 3
#define _VA4(…) 4
#define _VA5(…) 5
#define _VA6(…) 6
#define _VA7(…) 7
#define _VA8(…) 8
#define _VA9(…) 9
#define _VA10(…) 10
#define _VA11(…) 11
#define _VA12(…) 12
#define _VA13(…) 13
#define _VA14(…) 14
#define _VA15(…) 15
#define _VA16(…) 16

#define VA_NUM_ARGS(…) VA_NUM_ARGS_IMPL(__VA_ARGS__, PP_RSEQ_N(__VA_ARGS__) )
#define VA_NUM_ARGS_IMPL(…) VA_NUM_ARGS_N(__VA_ARGS__)

#define VA_NUM_ARGS_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
_11,_12,_13,_14,_15,_16,N,…) N

#define PP_RSEQ_N(…) \
_VA16(__VA_ARGS__),_VA15(__VA_ARGS__),_VA14(__VA_ARGS__),_VA13(__VA_ARGS__),\
_VA12(__VA_ARGS__),_VA11(__VA_ARGS__),_VA10(__VA_ARGS__), _VA9(__VA_ARGS__),\
_VA8(__VA_ARGS__),_VA7(__VA_ARGS__),_VA6(__VA_ARGS__),_VA5(__VA_ARGS__),\
_VA4(__VA_ARGS__),_VA3(__VA_ARGS__),_VA2(__VA_ARGS__),_VA1(__VA_ARGS__),\
_VA0(__VA_ARGS__)

Enjoy
Paul

Comment on Variadic macro to count number of arguments by Stan

Stan — Wed, 23 Feb 2011 13:36:14 +0000

Hi,

thanks for this interesting post.

However, the following code (as stated above) doesn’t work as expected in Visual Studio (I have tested on VS2010):

#define VA_NUM_ARGS(…) VA_NUM_ARGS_IMPL(__VA_ARGS__, 5,4,3,2,1)
#define VA_NUM_ARGS_IMPL(_1,_2,_3,_4,_5,N,…) N

// to verify, run the preprocessor alone (g++ -E):
VA_NUM_ARGS(x,y,z)

VS appears to have a bug regarding the __VA_ARGS__ expansion.

Here is a workaround, hope it will help those who struggle with it in VS as I did:

#define VA_NUM_ARGS(…) VA_NUM_ARGS_IMPL_((__VA_ARGS__, 5,4,3,2,1))
#define VA_NUM_ARGS_IMPL_(tuple) VA_NUM_ARGS_IMPL tuple
#define VA_NUM_ARGS_IMPL(_1,_2,_3,_4,_5,N,…) N

Best regards,
Stan.

Comment on Imitation of Java Generics by No

No — Wed, 09 Feb 2011 02:20:56 +0000

And this is why C++ programmers laugh when Java programmers talk about object models and what could be stripped away without loss.

Comment on Imitation of Java Generics by NN

NN — Tue, 08 Feb 2011 12:57:25 +0000

Your example is rewritten in C++ using static interface.
Like it is done in std:: classes .

template
class priority_queue;

I don’t remember myself needing this type check so often.

Since C++ doesn’t have a standard interfaces like Comparable, in most cases you rely on compile-time interface.

Comment on Imitation of Java Generics by Motti Lanzkron

Motti Lanzkron — Mon, 07 Feb 2011 19:29:13 +0000

As Zara said, you seem to be underestimating concepts. Concepts were supposed to be non-intrusive, you wouldn't have to derive your class from Comparable it would be deduced automatically from the concept.

auto concept Comparable {
    bool operator<(const T&, const T&);
};

And you could also adapt types to meet the static interface.

concept_map Comparable {
   bool operator<(const SomeType& lhs, const SomeType&rhs) { 
      return lhs.IsLessThan(rhs);
  }