c++ 11 supported

source/tensor/XDevice.cpp

@@ -266,6 +266,10 @@ XDevManager::XDevManager()
 {
     Clear();
     Init();
+
+#ifndef USE_CPP11
+    fprintf(stderr, "Warning!!! c++ 11 is RECOMMENDED for compilation.\n");
+#endif
 }
 
 /* de-constructor */

source/tensor/XGlobal.h

@@ -43,6 +43,10 @@
 /* the nts (NiuTrans.Tensor) namespace */
 namespace nts {
 
+#if (__cplusplus >= 201103L || _MSC_VER >= 1700)
+#define USE_CPP11
+#endif
+
 #define _XINLINE_  
 
 //#define DOUBELPRICSION

source/tensor/XTensor.cpp

@@ -192,6 +192,36 @@ XTensor::XTensor(const XTensor &reference)
     isTmp  = reference.isTmp;
 }
 
+/* copy constructor (with right value reference) */
+#ifdef USE_CPP11
+XTensor::XTensor(const XTensor &&reference)
+{
+    Init();
+    SetDataPointer();
+    id = MakeTensorID();
+    ShallowCopy(reference);
+    data = NULL;
+    dataHost = NULL;
+    
+    devID = reference.devID;
+    mem = reference.mem;
+    data = reference.data;
+    signature = reference.signature;
+        
+    /* what we really want to do is "reference.data = NULL;"
+       As "reference" is constant, we cannot reset reference.data
+       here. So we save the ADDRESS of reference.data in
+       reference.dataP, and do this work by updating "*reference.dataP".
+       This is VERY trick and might not be the best solution :) */
+    *reference.dataP = NULL;
+
+    XLink::Replace(&reference, this);
+
+    isInit = true;
+    isTmp  = reference.isTmp;
+}
+#endif
+
 /* de-constructor */
 XTensor::~XTensor()
 {
@@ -294,7 +324,6 @@ void XTensor::ShallowCopy(const XTensor &tensor)
 /* overloading of the equal-sign */
 XTensor& XTensor::operator= (const XTensor& tensor)
 {
-    
     /* we must make a hard copy of the tensor if it is the input
        of another node. */
     if(outgo.tailNum > 0){
@@ -369,6 +398,53 @@ XTensor& XTensor::operator= (const XTensor& tensor)
     return *this;
 }
 
+/* overloading of the equal-sign (with right value reference) */
+XTensor& XTensor::operator= (const XTensor&& tensor)
+{
+    /* we must make a hard copy of the tensor if it is the input
+       of another node. */
+    if(outgo.tailNum > 0){
+        int dims[MAX_TENSOR_DIM_NUM];
+        memcpy(dims, dimSize, order * sizeof(int));
+        dims[0] = -dims[0];
+        
+        XTensor * newTensor = new XTensor(order, dims, dataType, denseRatio, devID, mem);
+        newTensor->SetTMPFlag();
+        newTensor->data = data;
+        newTensor->dataHost = dataHost;
+        newTensor->signature = tensor.signature;
+        
+        XLink::Replace(this, newTensor);
+        XLink::ClearOutgoing(this);
+        XLink::ClearIncoming(this);
+        newTensor->ShallowCopy(this);
+
+        data = NULL;
+        dataHost = NULL;
+    }
+    
+    DestroyData();
+
+    ShallowCopy(tensor);
+    
+    isInit = true;
+    devID = tensor.devID;
+    mem  = tensor.mem;
+    data = tensor.data;
+    signature = tensor.signature;
+        
+    /* what we really want to do is "reference.data = NULL;"
+       As "reference" is constant, we cannot reset reference.data
+       here. So we save the ADDRESS of reference.data in
+       reference.dataP, and do this work by updating "*reference.dataP".
+       This is VERY trick and might not be the best solution :) */
+    *tensor.dataP = NULL;
+
+    XLink::Replace(&tensor, this);
+
+    return *this;
+}
+
 /* overloading of the plus-sign */
 XTensor XTensor::operator+ (const XTensor& tensor)
 {

source/tensor/XTensor.h

@@ -189,6 +189,11 @@ public:
     /* copy constructor */
     XTensor(const XTensor &reference);
 
+    /* copy constructor (with right value reference) */
+    #ifdef USE_CPP11
+    XTensor(const XTensor &&reference);
+    #endif
+
     /* de-constructor */
     ~XTensor();
 
@@ -204,6 +209,11 @@ public:
     /* overloading of the equal-sign */
     XTensor& operator= (const XTensor &tensor);
 
+    /* overloading of the equal-sign (with right value reference) */
+    #ifdef USE_CPP11
+    XTensor& operator= (const XTensor &&tensor);
+    #endif
+
     /* overloading of the plus-sign */
     XTensor  operator+ (const XTensor &tensor);