constexpr

Author: elloop

understanding-c++11/constexpr.cpp

@@ -0,0 +1,12 @@
+#include "constexpr.h"
+NS_BEGIN(elloop)
+NS_BEGIN(constexpr)
+
+TEST(Constexpr, UseDefinedConstData) {
+#ifdef _MSC_VER
+#else
+	EXPECT_EQ(6, birthMonth);
+#endif
+}
+NS_END(constexpr)
+NS_END(elloop)

understanding-c++11/constexpr.h

@@ -0,0 +1,94 @@
+#ifdef _MSC_VER
+#pragma once
+#else
+_Pragma("once")
+#endif
+#include "inc.h"
+
+NS_BEGIN(elloop)
+NS_BEGIN(constexpr)
+
+#ifdef _MSC_VER
+#else
+//---------------------- const expression function ----------------------
+// Four condition:
+// 1. function body can contain only a return statement(except for use,typedef...)
+// 2. must have return value(cannot be void).
+// 3. must be defined, before using.
+// 4. return statement cannot contains: non-const expression, global data. 
+// it must be a const expression.
+
+// example:
+constexpr int data() { const int i = 1; return i;} // wrong, too many statements.
+constexpr void f() {}							   // wrong, must have return val.
+
+constexpr int cf();
+constexpr int c = cf();							   // wrong, cf is not defined.
+
+int globalInt(100);
+constexpr int g() { return globalInt; }			   // wrong, global data..
+
+int nonConstFunc() { return 1;}
+constexpr int k() { return nonConstFunc(); }	   // wrong, nonConstFunc is not const expression.
+
+const int returnConst { return 11;}
+constexpr int p() { return returnConst(); }        // wrong, returnConst is not const expression.
+
+//---------------------- const expression value ----------------------
+// 1.
+// const int j=1;
+// constexpr int j = 1;
+// what's the difference?
+// const's j, 如果j在全局的名字空间，编译器一定会为它产生数据;
+// constexpr's j 编译器不会为它生成数据（除非代码显示地使用了它的地址)。
+
+// 2. user defined const expression data.
+// Two rules:
+// 1. constexpr constructor must empty body.
+// 2. initial list can only use constexpr expression.
+
+struct Data {
+	constexpr Data(int y, int m, int d) : year(y), month(m), day(d) {}
+	constexpr int year() {return year;}
+	constexpr int month() {return month;}
+	constexpr int day() {return day;}
+private:
+	int year;
+	int month;
+	int day;
+};
+constexpr Data kBirth(1988, 5, 12);
+constexpr int birthMonth = kBirth.month();
+
+//---------------------- use in template ----------------------
+template <typename T>
+constexpr T makeConstexpr(T t) {
+	return t;
+}
+
+struct NonConstexpr {
+	int i;
+	NonConstexpr() {i = 1;}
+};
+
+void test() {
+	NonConstexpr n1;
+	NonConstexpr n2 = makeConstexpr(n1);			// constexpr is ignored, because n1 is not constexpr
+	constexpr int i = makeConstexpr(10);			// ok
+}
+
+//---------------------- constexpr meta programming ----------------------
+constexpr int fib(int n) {
+	return (n == 1) ? 1 : ((n == 2) ? 1 : fib(n-1) + fib(n-2));
+}
+
+int fibs[] = {
+	fib(11), fib(12), fib(20)
+};
+
+
+
+#endif
+
+NS_END(constexpr)
+NS_END(elloop)

understanding-c++11/rvalue_refrence_and_move_constructor.cpp

@@ -108,7 +108,7 @@ void targetFunction(const int && m) { LOGD("const rvalue reference target\n"); }
 void targetFunction(const int & m) { LOGD("const lvalue reference target\n"); }
 /*
 template <typename T>
-void iAmForwarding(T&& t) {
+void forwarding(T&& t) {
 	targetFunction(std::forward<T>(t));
 }
 */
@@ -119,10 +119,10 @@ TEST(RValueReference, PerfectForward) {
 	const int c = 1;
 	const int d = 0;
 
-	iAmForwarding(a);
-	iAmForwarding(std::move(b));
-	iAmForwarding(c);
-	iAmForwarding(std::move(d));
+	forwarding(a);
+	forwarding(std::move(b));
+	forwarding(c);
+	forwarding(std::move(d));
 
 }
 

understanding-c++11/rvalue_refrence_and_move_constructor.h

@@ -23,8 +23,10 @@ NS_BEGIN( rvalue_refrence_and_move_constructor )
 // 1. is_rvalue_reference
 // 2. is_lvalue_reference
 
-// ------------------ std::move ------------------
+// ------------------ std::move<T> & std::forward<T> ------------------
 // std::move is equal to operation: static_cast<T&&>(lvalue)
+// std::forward has the same function with std::move, like an alias of move, but
+// is specially used for template function forwarding params.
 // 强制转换为右值，move(x) 将会调用x的移动构造函数，被转化的x并不会立即被析构，所以
 // 注意这个问题，参考 TEST(RValueReference, MoveConstructorTest)
 
@@ -209,10 +211,37 @@ void targetFunction(const int && m);
 void targetFunction(const int & m);
 
 // template function decide the type of t is simple:
-// 1. iAmForwarding's param is lvalue_reference -> template param type: T&
-// 2. iAmForwarding's param is rvalue_reference -> template param type : T&&
+// 1. forwarding's param is lvalue_reference -> template param type: T&
+// 2. forwarding's param is rvalue_reference -> template param type : T&&
 template <typename T>
-void iAmForwarding(T&& t) {
+void forwarding(T&& t) {
+	// QUESTION 1: why not use forwarding(T t)
+	// key: that will become a copy semantic, pass by value.
+
+	// QUESTION 2: figure out  
+	// 
+	// int a;
+	// forwarding(a);
+	// 
+	// why std::is_lvalue_reference<T&&>::value == 1 ?
+	// int&& fail to bind with a ? so becomes a int& instead??
+	bool same = std::is_same<int&, T&&>::value;  // same is true in vs2013.
+
+	// AND
+	// fowarding(move(a)); T is int&&
+	// so forwarding(int&& && t) -> forwarding(int&& t) [reference folding]
+
+	//psln(typeid(decltype(t)).name());
+	//psln(typeid(T).name());
+	//psln(std::is_lvalue_reference<T&&>::value);
+	//psln(std::is_rvalue_reference<decltype(t)>::value);
+	//targetFunction(std::forward<T>(t));
+
+	// NOTICE: 能接受右值的右值引用本身是个左值, 即t是个左值(即使传递进来的确实是个右值)
+	// 这样直接传递给targetFunction, 就会丢失原来的左右值属性，变成左值引用
+	// targetFunction(t);
+
+	// RIGHT WAY: forward会保持左右值属性.
 	targetFunction(std::forward<T>(t));
 }
 

understanding-c++11/understanding-c++11.vcxproj

@@ -83,6 +83,7 @@
     <ClCompile Include="attribute.cpp" />
     <ClCompile Include="auto.cpp" />
     <ClCompile Include="compatibility.cpp" />
+    <ClCompile Include="constexpr.cpp" />
     <ClCompile Include="constructor_test.cpp" />
     <ClCompile Include="decltype.cpp" />
     <ClCompile Include="initializer_test.cpp" />
@@ -110,6 +111,7 @@
     <ClInclude Include="alignof_alignas.h" />
     <ClInclude Include="attribute.h" />
     <ClInclude Include="auto.h" />
+    <ClInclude Include="constexpr.h" />
     <ClInclude Include="decltype.h" />
     <ClInclude Include="inline_namespace.h" />
     <ClInclude Include="lambda_test.h" />

understanding-c++11/understanding-c++11.vcxproj.filters

@@ -71,6 +71,9 @@
     <ClCompile Include="rvalue_refrence_and_move_constructor.cpp">
       <Filter>c++11</Filter>
     </ClCompile>
+    <ClCompile Include="constexpr.cpp">
+      <Filter>c++11</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="inc.h">
@@ -156,6 +159,9 @@
     <ClInclude Include="rvalue_refrence_and_move_constructor.h">
       <Filter>c++11</Filter>
     </ClInclude>
+    <ClInclude Include="constexpr.h">
+      <Filter>c++11</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="include">