Boost logo

Boost :

From: Eric Niebler (eric_at_[hidden])
Date: 2004-05-27 18:25:21

David Abrahams wrote:

> "Eric Niebler" <eric_at_[hidden]> writes:
>>Why is that confusing? That's how most other types in C++ behave:
>>int a,b; // a and b are undefined
>>a = b; // a and b are still undefined
> ^^^^^
> This is undefined behavior, actually.

Oops, you're right. Bad example. How about:

int a=0,b=0;
b=1; // b is 1, a is still 0

My point was that rule<> doesn't "do as the ints do", which can be
surprising to some. I would love for this to work:

rule<> a;

   rule <> b;

   // match balanced, nested parens.
   // b refers to itself by reference
   // (Note: ! means optional, no special syntax
   // required to get by-ref semantics here)
   b = '(' >> !b >> ')';

   // a assumes b's behavior
   a = b;

// a still has b's behavior.
// this matches balanced, nested parens
parse( "(())", a );

Currently, this crashes because 'a' holds 'b' by reference and tries to
access it after 'b' has gone out of scope and been destroyed. I haven't
yet thought of a way to make this work, but I'm not convinced it's

I now agree that rules should have by-ref semantics when embedded in
another rule. But in simple assignment statements ("a=b;"), it would be
nice if rules behaved as the ints do. I'm sure this will draw fire from
the EBNF purists who want rule assignment to have by-ref semantics, but
IMO C++ types that don't have normal copy and assignment semantics are
just hard to work with.

Eric Niebler
Boost Consulting

Boost list run by bdawes at, gregod at, cpdaniel at, john at