Re: How to pass a huge matrix to a function
Vladislav.Lazarenko@gmail.com wrote:
On Sep 19, 4:42 pm, Erik Wikstr?m <Erik-wikst...@telia.com> wrote:
It is a defect in the language, you must put a space between the two
or the compiler will interpret it as the >> operator, i.e.
It is not a defect! C++ is really powerful and complex language. In
template argument list you should always use "> >" to tell compiler
that this is not right shift operator. See
http://www.comeaucomputing.com/techtalk/templates/#shiftshift
There was a discussion about possibly adjusting the grammar so that
it accommodates the angle brackets not separated by whitespace, and
Andrew Koenig (IIRC) said it was possible. I don't have a link to
the discussion, but it can probably be located on Google Groups
relatively quickly. In the code
vector<vector<double>> v;
there can be no right shift, since a type (double) cannot be right-
shifted. But the ambiguity becomes apparent in this situation:
template<int a> class foo {};
vector<foo<12>> b;
Are we shifting 12 to the right 'b' times, or are we defining 'b'
as a 'vector' of 'foo<12>'? If the former, there are syntax errors
since the template argument list is not closed, or maybe 'b' is not
defined. If the latter, the code is OK (unless 'b' has been already
declared or some such). The compiler cannot decide to interpret the
code in such a way that it's well-formed.
To solve this, the same requirement as with a single angle bracket
(that can be interpreted as the greater-than operator) would be used:
if it can close the declaration of a template, it shall. Ambiguity
is resolved with parentheses.
Here is another (contrived) example of what would be ambiguous code
had there been no rule "disambiguation is in favor of closing angle
bracket":
template<int a> class foo { foo(int); };
template<int a>
bool operator > (foo<a> const&, int);
const int y = 2;
const int z = 3;
int main() {
foo< 12 > (z) > y; // ambiguious?
}
The ambiguity is resolved by the "any angle bracket closes the
previous angle bracket", and the interpretation is:
( foo<12>(z) ) > y; // temporary of type foo<12> constructed
// with 3 as argument is compared to 2
And if you want it to be interpreted as the 'greater-than'
operator, use parentheses:
foo< (12 > (z)) > y; // definition of 'y' of type foo<1>
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask