Known Limitations 
=================
The Intel(R) Premier Support website <https://premier.intel.com/> contains 
more up to date information on errata and the availability of new versions 
of the compiler. 

This initial product version of the Intel(R) C++ Compiler for 64 bit applications
has the following limitations: 
 - All the optimizations enabled for C have not been enabled for C++ at this time.



The following are known defects in the Intel(R) C++ Compiler, which might 
be fixed in a future version. This list is divided into defects that 
can affect both C and C++, and defects that affect only C++ programs. 

Defects Affecting Only C++ Programs
===================================

The Intel(R) C++ compiler conforms to the C++ standard.  The Intel(R) C++ Compiler,
at this time, does not fully support the legacy <iostream.h>.  If you need support
for the legacy <iostream.h>, additional information is available on the Intel(R)
Premier Support web site.  Please see the main release notes for instructions on 
how to obtain a support account.


Based pointers are not fully supported in C++ code. Although they are 
accepted (i.e. do not result in an error), they are not taken into 
account in name mangling, for example.


Defects Affecting C and C++ Programs 
====================================

Using -quiet in ecc.cfg to suppress Warning message
--------------------------------------------------

 If ECCCFG environment variable is not defined and set to ecc.cfg
 (full path), invoking 'ecc' (old driver name) will not process
 ecc.cfg and continue to emit the Warning message about using old
 driver names.


The Intel(R) C++ Compiler does not allow initialization of an unsigned 
short array with a wide character literal string when the string is 
cast to unsigned short *. The following code fragment fails to compile 
with the Intel(R) C++ Compiler for this reason: 

	struct { 
		int buf[32]; 
		} s = { (unsigned short) L"hello" }; 

A workaround for this problem is to remove the cast to unsigned short *, 
because it is unnecessary. The same problem affects unsigned char arrays 
initialized with non-wide string literals. 

The Intel(R) C++ Compiler issues an error if an identifier with a base type 
is redeclared using a different base type of the same size. As a result, 
the following code fragment fails to compile with the Intel(R) C++ Compiler: 

	int a; 
	long a; 
	float a;

The Intel(R) C++ Compiler generates an error for a character array 
initialization containing a mixture of characters and strings such as 
the following: 

	char a[5] = {'a', "bcd"};
 

Limitations and Tool Notes
==========================

Use of Friend Injection: Not Recommended Sometimes a class is a member 
of a namespace , and contains a friend declaration of a function not 
already declared. In such cases, the Intel(R) C++ Compiler injects the 
function declaration into the namespace containing the class, even if 
the class definition is not lexically within the namespace definition. 



Function Declaration in Function Scope of Function Defined in a Namespace 

In accordance with the C++ language specification, if a function 
declaration is encountered within a function definition, the function 
referenced is taken to be another member of the namespace of the 
containing function, whether or not the containing function definition 
is lexically within a namespace definition.