IDL to C++11 1.1 RTF — Open Issues - OMG Issue Tracker

Key: CPP1111-13

Legacy Issue Number: 18433

Status: closed

Source: gmail.com ( daniel.kruegler@gmail.com)

Summary:

The wording in 6.29 says

"For each IDL type (T) of type: [..] an ostream inserter with the following signature will be provided:

// C++
std::ostream& operator<<(std::ostream &, T);

For all other types an ostream inserter with the following signature will be provided:

// C++
std::ostream& operator<<(std::ostream &, const T&);"

1) This wording is not clear in which namespace the operator<< overload shall be provided. It could be within the global namespace or within the namespace of type T.

The prototype implementation that I have seen provides these operators in the global namespace which makes them behave irregular:

The reason is that overloaded operators such as these IO inserters are found by argument-dependent name-lookup. The lookup will consider all declarations that are found at the point of usage and will look in the associated namespaces of the operands to find them. Consider the following example:

#include <iostream>
#include <vector>
#include <iterator>

namespace n {
struct A {};
}
std::ostream& operator<<(std::ostream& os, n::A)

{ return os; }

int main() { std::vector<n::A> v; std::copy(v.begin(), v.end(), std::ostream_iterator<n::A>(std::cout)); }

This program will not compile, because the involved template cannot "see" the operator<< overload. TRhis is so, because it is provided in the global namespace, but the operands are in namespace std:: and namespace n, resp. Adding overloads to namespace std is not valid, therefore the only option is to add the operator<< overload to namespace n:

#include <iostream>
#include <vector>
#include <iterator>

namespace n {
struct A {};
std::ostream& operator<<(std::ostream& os, n::A) { return os; }

}

int main()

{ std::vector<n::A> v; std::copy(v.begin(), v.end(), std::ostream_iterator<n::A>(std::cout)); }

This works and lets the ostream operator<< of A::n behave normally.

This example was intended to demonstrate that the provided operator<< overloads should be provided in the same namespace as the declared mapped types from the IDL (that is within the IDL module). The wording in 6.29 should be clarified in that regard.

2) The second part of above wording,

"For all other types an ostream inserter with the following signature will be provided:

// C++
std::ostream& operator<<(std::ostream &, const T&);"

can be read to be applicable for the arithmetic IDL types (bool, short, wchar_t, char, double, uint32_t, ...) or typedefs thereof, but that surely cannot be intended, because that would result in a compiler ambiguity when user code would include such a mapping header and would attempt to print such an arithmetic type on any std::ostream, e.g.

#include <iostream>
#include "some_idl.h"

int main()

{ std::cout << 12; // Error, ambiguity }

The wording in 6.29 should make clear that no operator<< overloads shall be provided for the basic data types or for typedefs thereof.

Reported: CPP11 1.0 — Wed, 6 Feb 2013 05:00 GMT

Disposition: Resolved — CPP11 1.1

Disposition Summary:

We had a detailed looked at the argument dependent lookup and what would technically
be feasible. We also had users that wanted to define their own ostream operators and
our spec defined methods were conflicting with that approach. Given that this feature
was mostly focused on debugging systems, we decided to remove this section
completely from the specification

Updated: Fri, 6 Mar 2015 20:58 GMT