Date post: | 14-Dec-2015 |
Category: |
Documents |
Upload: | joselyn-noakes |
View: | 215 times |
Download: | 0 times |
What's new in MicrosoftVisual C++ 2015 Preview
December 17th 2014
Marc Gré[email protected] http://www.nuonsoft.com/ http://www.nuonsoft.com/blog/
Agenda
C++11, C++14, C++17 Productivity Improvements Improved Performance C++ Cross-Platform Mobile Dev
C++11, C++14, C++17Increased standard compliancy
C++11 Core Language Features New or updated C++11 core language features
ref-qualifiers Partial support for constexpr Inheriting constructors char16_t and char32_t Unicode string literals User-defined literals Full defaulted and deleted functions support (partial in VC++2013) Extended sizeof() noexcept Inline namespaces Full Rvalue references compliant (partial VC++2013) Full alignment support (partial in VC++2013) Unrestricted unions
ref-qualifiers
rvalue references are well-known for function parameters, example: void foo(Bar&& bar);
How to apply rvalue reference to *this?class Foo {
void f1() const; // *this is const
void f2() &; // *this is an lvalue
void f3() &&; // *this is an rvalue
};
ref-qualifiers – Contrived Example
class BigObject {};class BigObjectFactory {public: BigObject Get() { return m_bigObject; } private: BigObject m_bigObject;};
BigObjectFactory aFactory; BigObject obj = aFactory.Get();
ref-qualifiers – Contrived Example
But what with this:BigObject obj = BigObjectFactory().Get();
The factory is a temporary object, but BigObject is still copied because *this is not an rvalue-reference
Solution: Make BigObject moveable Overload Get() for an rvalue-reference *this
ref-qualifiers – Contrived Example
class BigObject {};class BigObjectFactory {public: BigObject Get() const & { // *this is an lvalue return m_bigObject; // Deep copy } BigObject Get() && { // *this is an rvalue return std::move(m_bigObject); // move }private: BigObject m_bigObject;};
BigObjectFactory myFactory;
BigObject o1 = myFactory.Get(); // Deep copy
BigObject o2 = BigObjectFactory().Get();// Move
constexpr
Constant expressions Simple example
static constexpr size_t FACTOR = 2;constexpr size_t CalculateArraySize(size_t base){ return base * FACTOR;}...double arr[CalculateArraySize(123)];
Inheriting constructors
class Base{public: Base(int data) : m_data(data) {}private: int m_data;};class Derived : Base{public: Derived(const std::string& msg) : Base(1), m_msg(msg) {}private: std::string m_msg;};...Base b1(123); // OKDerived d1("Message"); // OKDerived d2(456); // NOT OK
Inheriting Constructorsclass Base{public: Base(int data) : m_data(data) {}private: int m_data;};class Derived : Base{public: using Base::Base; Derived(const std::string& msg) : Base(1), m_msg(msg) {}private: std::string m_msg;};...Derived d2(456); // OK
char16_t and char32_t
Existing character types: char: only 8 bits wchar_t: compiler-dependent size, not specified
by C++ standard! hard to use for platform independent code
New character types: char16_t and char32_t
char16_t and char32_t
In total 4 character types: char: stores 8 bits; can be used to store ASCII,
or as building block for UTF-8 encoded Unicode characters
char16_t: stores at least 16 bits; building block for UTF-16 encoded Unicode characters
char32_t: stores at least 32 bits; building block for UTF-32 encoded Unicode characters
wchar_t: stores a wide character of a compiler dependent size and encoding
char16_t and char32_t
A compiler can define the following new preprocessor defines: __STDC_UTF_32__: If defined then char32_t
represents a UTF-32 encoding, otherwise it has a compiler dependent encoding.
__STDC_UTF_16__: If defined then char16_t represents a UTF-16 encoding, otherwise it has a compiler dependent encoding.
Both not defined in VC++2015 Preview
char16_t and char32_t
New std::basic_string specializations: typedef basic_string<char> string; typedef basic_string<wchar_t> wstring; typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
char16_t and char32_t
Unfortunately, support for char16_t and char32_t stops here
No I/O stream classes support these new types
No version of cout/cin/… for these types
Unicode String Literals
New string literals: L: A wchar_t string literal with a compiler-
dependent encoding u8: A char string literal with UTF-8 encoding u: A char16_t string literal, which can be UTF-16
if __STDC_UTF_16__ is defined by the compiler U: A char32_t string literal, which can be UTF-32
if __STDC_UTF_32__ is defined by the compiler
Unicode String Literals
All can be combined with the R prefix for raw string literals:const char* s1 = u8R"(Raw UTF-8 encoded string literal)";
const wchar_t* s2 = LR"(Raw wide string literal)";
const char16_t* s3 = uR"(Raw char16_t string literal)";
const char32_t* s4 = UR"(Raw char32_t string literal)";
User-Defined Literals
C++ has standard literals such as: 'a': character "character array": zero-terminated array of
characters, C-style string 3.14f: float floating point value 0xabc: hexadecimal value
User-Defined Literals
Start with _ Implemented in a literal operator:
Raw mode: op receives sequence of characters Cooked mode: op receives an interpreted type Example: literal 0x23
Raw mode op receives ‘0’, ‘x’, ‘2’, ‘3’ Cooked mode op receives the integer 35
User-Defined Literals – Cooked Mode
Has 1 parameter to process numeric values Type can be unsigned long long, long double,
char, wchar_t, char16_t or char32_t or 2 parameters to process strings
a character array the length of the character array example: (const char* str, size_t len)
User-Defined Literals – Cooked Mode
Example: cooked mode complex number literal
std::complex<double> operator"" _i(long double d){ return std::complex<double>(0, d);}
std::complex<double> c1 = 9.634_i;auto c2 = 1.23_i; // type is std::complex<double>
User-Defined Literals – Cooked Mode
Example: cooked mode std::string literal
std::string operator"" _s(const char* str, size_t len){ return std::string(str, len);}
std::string str1 = "Hello World"_s;auto str2 = "Hello World"_s; // type is std::stringauto str3 = "Hello World"; // type is const char*
User-Defined Literals – Raw Mode
Example: raw mode complex number literal
std::complex<double> operator"" _i(const char* p){ // Implementation omitted; it requires parsing the C-style // string and converting it to a complex number.}
Full Defaulted and Deleted Functions Support
=default Ask the compiler to forcefully generate the default
implementation Example:
class C{public: C(int i) {} C() = default;};
Full Defaulted and Deleted Functions Support
=delete Forcefully delete an implementation
Error message states intent, better error message than making it private without implementation
Example:class C{public: C() = delete; C(const C& src) = delete; C& operator=(const C& src) = delete;};C c;//error C2280:'C::C(void)': attempting to reference a deleted function
Full Defaulted and Deleted Functions Support
=delete can be used to disallow calling a function with a certain type
Example:void foo(int i) { }...foo(123);foo(1.23); // Compiles, but with warning
Disallow calling foo() with doubles by deleting a double overload of foo():void foo(int i) { }void foo(double d) = delete;...foo(123);foo(1.23); // error C2280: 'void foo(double)' : // attempting to reference a deleted function
Extended sizeof()
sizeof() on class members without an instance
Example:
class Bar {};
class Foo {public: Bar m_bar;};
sizeof(Foo::m_bar);
noexcept
Double meaning: noexcept to mark a function as non-throwing
void func1(); // Can throw anythingvoid func2() noexcept(expr); // A constant expression returning a Boolean
// true means func2 cannot throw // false means func2 can throw
void func3() noexcept; // = noexcept(true)
If a noexcept-marked function does throw at runtime, terminate() is called
Note that old exception specifications are deprecated since C++11
noexcept noexcept as an operator: noexcept(expr) Example:
bool b1 = noexcept(2 + 3); // b1 = truebool b2 = noexcept(throw 1); // b2 = false
void func1() { }bool b3 = noexcept(func1());
void func2() noexcept { }bool b4 = noexcept(func2()); // b4 = true
Used by the standard library to decide between moving or copying
Thus, mark your move ctor and move assignment operator noexcept
// b3 = false
Inline Namespace
Intended for libraries to support versioning Example:
// file V98.h:namespace V98 { void f(int); // does something}
// file V99.h:inline namespace V99 { void f(int); // does something better than the V98 version void f(double); // new feature}
// file MyLibrary.h:namespace MyLibrary { #include "V99.h" #include "V98.h"}
#include "MyLibrary.h"using namespace MyLibrary;
V98::f(1); // old versionV99::f(1); // new versionf(1); // default version
C++11 Core Language Concurrency Features
New or updated C++11 core language concurrency features quick_exit() and at_quick_exit() Full support for thread-local storage (partial in
VC++2013) Magic statics
quick_exit() and at_quick_exit()
quick_exit() terminates application as follows: Calls all functions registered with at_quick_exit() Terminates application
Except at_quick_exit() handlers, no other cleanup is done
No destructors are called
Thread-Local Storage
Keyword: thread_local Each thread gets its own instance Example:
thread_local unsigned int data = 1;
Magic Statics
Thread-safe “Magic” statics Static local variables are initialized in a
thread-safe way No manual synchronization needed for
initialization Using statics from multiple threads still
requires manual synchronization
Magic Statics
Example: simple thread-safe singleton:
static Singleton& GetInstance(){ static Singleton theInstance; return theInstance;}
C++11 Core Language C99 Features
New or updated C++11 core language C99 features __func__
__func__
Standard way to get the name of a function
int _tmain(int argc, _TCHAR* argv[]){ cout << __func__ << endl; return 0;}
Output:
wmain
C++14 Core Language Features
New or updated C++14 core language features Binary literals auto and decltype(auto) return types Lambda capture expressions Generic lambdas Digit separators (will be in RTM) Sized deallocation (partial support)
Binary Literals
int value = 0b1111011; // = 123
auto and decltype(auto) Return Types
Both auto and decltype(auto) can be used to let the compiler deduce the return type
auto strips ref-qualifiers (lvalue and rvalue references) and strips cv-qualifiers (const and volatile)
Decltype(auto) does not strip those
auto and decltype(auto) Return Types
Example: return type will be intauto Foo(int i){ return i + 1;}
Example: return type will be doubletemplate<typename T>auto Bar(const T& t){ return t * 2;}...auto result = Bar<double>(1.2);
auto and decltype(auto) Return Types
Multiple return statements are allowed but all need to be of exactly the same type
Following won’t compile returns int and unsigned int
auto Foo(int i){ if (i > 1) return 1; else return 2u;}
auto and decltype(auto) Return Types
Recursion allowed but there must be a non-recursive return before the recursive call
Correct:auto Foo(int i){ if (i == 0) return 0; else return i + Foo(i - 1);}
Wrong:auto Foo(int i){ if (i > 0) return i + Foo(i - 1); else return 0;}
decltype(auto)
Quick reminder:static const string message = "Test";
const string& Foo(){ return message;}
...
auto f1 = Foo();decltype(Foo()) f2 = Foo();decltype(auto) f3 = Foo();
Type: string Type: const string& Type: const string&
auto and decltype(auto) Return Types
decltype(auto) as return type Example:
auto Foo1(const string& str){ return str;}
Return Type: string Return Type: const string&
decltype(auto) Foo2(const string& str){ return str;}
decltype(auto) a = Foo1("abc");decltype(auto) b = Foo2("abc");
Lambda Capture Expressions
Capture expressions to initialize lambda variables
Example:float pi = 3.1415;auto myLambda = [myCapture = "Pi: ", pi]{ std::cout << myCapture << pi; };
Lambda has 2 variables: myCapture: a string (not from the enclosing scope)
with value “Pi: “ pi: captured from the enclosing scope
Lambda Capture Expressions
Allow moving variables into the lambda Example:
auto myPtr = std::make_unique<double>(3.1415);auto myLambda = [p = std::move(myPtr)]{ std::cout << *p; };
Lambda has 1 variable: p: a unique_ptr captured and moved from the
enclosing scope (could even be called myPtr)
Generic Lambdas
Lambda parameters can be declared as auto auto doubler = [](const auto& value){ return value * 2; };
...
vector<int> v1{ 1, 2, 3 };transform(begin(v1), end(v1), begin(v1), doubler);
...
vector<double> v2{ 1.1, 2.2, 3.3 };transform(begin(v2), end(v2), begin(v2), doubler);
Digit Separators (will be in RTM)
Single quote character Example:
int number1 = 23'456'789; // The number 23456789
float number2 = 0.123'456f; // The number 0.123456
C++14 Library Features New or updated C++14 library features
Standard user-defined literals Null forward iterators quoted() Heterogeneous associative lookup Compile-time integer sequences exchange() Dual-range equal(), is_permutation(), mismatch() get<T>() tuple_element_t
Standard User-Defined literals “s” for creating std::strings
auto myString = "Hello World"s; “h”, “min”, “s”, “ms”, “us”, “ns”, for creating
std::chrono::duration time intervals auto myDuration = 42min;
“i”, “il”, “if” for creating complex numbers complex<double>, complex<long double>, and complex<float> respectively auto myComplexNumber = 1.3i;
C++17 Core Language Features
New or updated C++17 core language features Removing trigraphs Resumable functions (proposal for C++17)
Removing Trigraphs
Trigraph = sequence of 3 characters
TrigraphPunctuation Character
??= #
??( [
??/ \
??) ]
??' ^
??< {
??! |
??> }
??- ~
Resumable Functions (proposal for C++17)
Based on concept of coroutines Coroutine is a generalized routine supporting:
Invoke Return Suspend Resume
Resumable Functions (proposal for C++17)
Visual C++ 2015 Preview resumable functions restrictions 64-bit targets only Manually add /await compiler switch Manually disable /RTC1 (run-time error checks) Manually disable /sdl (additional security
checks) Currently in <experimental\resumable>
Resumable Functions – Async Operations
future<int> calculate_the_answer() // This could be some long running computation or I/O{ return async([] { this_thread::sleep_for(3s); return 42; });}
future<void> coro() // A resumable function{ cout << "coro() starting to wait for the answer..." << endl; auto result = __await calculate_the_answer(); cout << "got answer " << result << endl;}
int main(){ auto fut = coro(); cout << "main() is writing something" << endl; fut.get(); // Before exiting, let's wait on our asynchronous coro() call to finish. return 0;}
coro() starting to wait for the answer...
main() is writing something
got answer 42
23
6/5
14
5/6
Resumable Functions – Generator Pattern
#include <experimental\resumable>#include <experimental\generator>
using namespace std;using namespace std::experimental;
generator<int> fib(){ int a = 0; int b = 1; for (;;) { __yield_value a; auto next = a + b; a = b; b = next; }}
int main(){ for (auto v : fib()) { if (v > 50) { break; } cout << v << endl; }}
0
1
1
2
3
5
8
13
21
34
TS Library Features
New or updated Technical Specification library features File system “V3”
Productivity ImprovementsEnhanced productivity & build-time
improvements
Productivity & Build-Time Improvements
Improved IntelliSense database buildup Incremental linking with LTCG enabled Incremental linking for static libraries
Changes to static libraries referenced by other code modules now link incrementally
New fast PDB generation techniques: /Debug:FastLink Substantially decreases link times
Object file size reduction Multithreading in the linker New Visual Studio Graphics Analyzer (VSGA)
Productivity Improvements
Simplified QuickInfo for template deduction
VC++2013
VC++2015
New Refactorings
Rename symbol Implement pure virtuals Create declaration or definition Move function definition Convert to raw string literal Extract function (available from Visual Studio
Gallery)
Demo
New Refactorings
Improved Performance
Improved Performance Improvements to automatic vectorization
Vectorization of control flow (if-then-else) Vectorization with /O1 (minimize size) enabled Vectorizing more range-based for loops
Improvements to scalar optimizations Better code gen of bit-test operations Control flow merging and optimizations (loop-if switching) Better code gen for std::min and std:max
ARM32 code generation improvements
C++ Cross-Platform Mobile Dev
C++ Cross-Platform Mobile Dev
VC++ 2015 Preview has 2 compilers: VC++ compiler to target Windows platforms Clang to target Android (iOS coming in the near
future) Android support:
Build C++ dynamic shared libs and static libs Libs are consumed with Java, Xamarin , …
Build Native-Activity apps, pure C++
Demo
Android Native-Activity App
Questions
?