C++ 11 右值引用

右值引用解决的问题

右值引用是 C++11 中最重要的新特性之一，它解决了C++中大量的历史遗留问题，使C++标准库的实现在多种场景下消除了不必要的额外开销(如std::vector, std::string)，也使得另外一些标准库成为可以实现的可能。在 C++11 之前，移动语义的确实是C++饱受诟病的问题之一。

使用右值引用特性，可以实现：移动语义(move) 和 完美转发(perfect forwarding)。

C++11之前与Java的对比

右值引用与对象的资源所有权的交换复制有关。

在之前初学Java时，我们就要明确两个概念：深复制 和 浅复制 。

深复制：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

浅复制：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

在Java当中，所有的参数与赋值符号，实现的所有权转移都是使用传递引用，这里的引用与C中的引用概念类似，但C中的引用在使用过程中并不能改变引用的对象。Java 示例代码：

1
2
3
4
5
6
7
8
9
10
11
public static void main(String args[]) {
       long t1 = System.currentTimeMillis();
       Professor p = new Professor("wangwu", 50);
       Student s1 = new Student("zhangsan", 18, p);
       Student s2 = s1; // 浅复制
       s2.p.name = "lisi";
       s2.p.age = 30;
       System.out.println("name=" + s1.p.name + "," + "age=" + s1.p.age);
       long t2 = System.currentTimeMillis();
       System.out.println(t2-t1);
   }

在上述代码中，s2改变则s1也会随之改变，很多情况下，当把s1放到一个函数参数位置上当作参数，参数获取的仍然也是s1的引用。但有一些函数提供复制的语义，如字符串的 “+” 操作符，它会将两个字符串拼成一个，但却是在内存中重新分配了空间。

浅复制 是移动语义的实现方法，速度快，同时能够保证不同作用域可以操作同一个对象。而当我们需要使用复制语义存储某一对象的副本时，例如我们存储一个Student对象的副本到ArrayList中，当我们改变了Student，ArrayList中的也随之改变，这并不是我们想要的结果，因此，需要使用 深复制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Student implements Serializable { 
    Student(String name, int age, Professor p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }
    public Object deepClone() {
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return (oi.readObject());
    }
}

上述代码使用输入输出流将对象 串行化 之后进行了复制，返回了复制的对象的引用，调用这个函数可以获得一个Studnet的实例的副本。

在C++中，浅复制代码可以写成下面这样：

1
2
3
4
5
6
7
8
9
10
int main() 
{
        Professor p = Professor("wangwu", 50);
        Student s1 = new Student("zhangsan", 18, p);
        Student s2 = s1; // 深复制
        s2.p.name = "lisi";
        s2.p.age = 30;
        cout<< "name=" + s1.p.name + "," + "age=" + s1.p.age << endl;
        return 0;
    }

而在C++的表现却是s1与s2并不是指向同一个对象，s1的改变并不会影响到s2中的值。 赋值符号”=”在这里会调用s2的复制构造函数，将s1当做复制构造函数的参数进行调用。如果不使用指针，无法实现Java中的浅复制。

C++之所以与Java在内存管理方面存在上面所述的差异，原因是他们两种语言的内存回收方式的不同。C++（RAII机制）在栈上创建的对象(如局部变量)在离开作用于就会被析构，在堆上分配内存的对象只有在调用 delete 之后或者程序结束之后才会释放，而Java采用垃圾回收算法来判断是否回收创建的对象。

C++的指针设计简单，应用灵活，但却很容易造成内存泄漏(即便采用 谁开发谁治理 谁负责申请内存谁就负责销毁的方法，在一些过程函数中难以定义“谁”，且在多人协作容易出现问题)，Java虽然采用垃圾回收机制却仍然无法避免使用不当产生的内存泄漏。

C++11右值引用

右值引用是C++11引入的与Lambda表达式齐名的重要特征之一。

右值引用了解之前需要明确这几个定义：左值、右值，C++11标准中将右值划分出的纯右值、将亡值。

左值(lvalue, left value)，顾名思义就是赋值符号左边的值。准确来说，左值是表达式（不一定是赋值表达式）后依然存在的持久对象。函数名和变量名（实际上是函数指针③和具名变量，具名变量如std::cin、std::endl等）、返回左值引用的函数调用、前置自增/自减运算符连接的表达式++i/–i、由赋值运算符或复合赋值运算符连接的表达式(a=b、a+=b、a%=b）、解引用表达式*p、字符串字面值”abc”等。

右值(rvalue, right value)，右边的值，是指表达式结束后就不再存在的临时对象。

纯右值(prvalue, pure rvalue)，纯粹的右值，要么是纯粹的字面量，例如 10, true；要么是求值结果相当于字面量或匿名(不具名)临时对象，例如 1+2。非引用返回的临时变量、运算表达式产生的临时变量、原始字面量、Lambda 表达式都属于纯右值。

将亡值(xvalue, expiring value)，是 C++11 为了引入右值引用而提出的概念（因此在传统 C++中，纯右值和右值是统一个概念），也就是即将被销毁、却能够(或者说要使用移动)被移动的值。

将亡值可能稍有些难以理解，我们来看这样的代码：

1
2
3
4
5
std::vector<int> createAVector() {
    std::vector<int> res = {1, 2, 3, 4};
    return res;
}
std::vector<int> v = createAVector();

在这样的代码中，函数 createAVector 的返回值 res 在内部创建然后被赋值给 v，然而 v 获得这个对象时，会将整个 res 拷贝一份，然后把 res 销毁，如果这个 res 非常大，这将造成大量额外的开销（这也就是传统 C++ 一直被诟病的问题）。在最后一行中，v 是左值、createAVector() 返回的值就是右值（也是纯右值）。

但是，v 可以被别的变量捕获到，而 createAVector() 产生的那个返回值作为一个临时值，一旦被 v 复制后，将立即被销毁，无法获取、也不能修改。

将亡值就定义了这样一种行为：临时的值能够被识别、同时又能够被移动。

需要拿到一个将亡值，就需要用到右值引用的申明：T &&，其中 T 是类型。右值引用的声明让这个临时值的生命周期得以延长、只要变量还活着，那么将亡值将继续存活。

C++11 提供了 std::move 这个方法将左值参数无条件的转换为右值，有了它我们就能够方便的获得一个右值临时对象，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void reference(std::string& str) {
    std::cout << "左值" << std::endl;
}
void reference(std::string&& str) {
    std::cout << "右值" << std::endl;
}
int main()
{
    std::string  lv1 = "string,";       // lv1 是一个左值
    // std::string&& r1 = s1;           // 非法, 右值引用不能引用左值
    std::string&& rv1 = std::move(lv1); // 合法, std::move可以将左值转移为右值
    std::cout << rv1 << std::endl;      // string,
    const std::string& lv2 = lv1 + lv1; // 合法, 常量左值引用能够延长临时变量的申明周期
    // lv2 += "Test";                   // 非法, 引用的右值无法被修改
    std::cout << lv2 << std::endl;      // string,string
    std::string&& rv2 = lv1 + lv2;      // 合法, 右值引用延长临时对象声明周期
    rv2 += "Test";                      // 合法, 非常量引用能够修改临时变量
    std::cout << rv2 << std::endl;      // string,string,string,
    reference(rv2);                     // 输出左值
    return 0;
}

注意：rv2 虽然引用了一个右值，但由于它是个具名变量可以在后面的代码中使用，所以 rv2 是一个左值。

在程序设计中，我们重点的是如何使用右值引用才能使程序效率提高，而不是区分哪些是左值，哪些是右值。

事实上，将亡值不过是C++11提出的一块晦涩的语法糖。它与纯右值在功能上及其相似，如都不能做操作符的左操作数，都可以使用移动构造函数和移动赋值运算符。当一个纯右值来完成移动构造或移动赋值任务时，其实它也具有“将亡”的特点。一般我们不必刻意区分一个右值到底是纯右值还是将亡值。

std::move(val) 和 std::forward(T&& val) 的作用

std::move(val) 会将val强制转换成右值并返回该右值，代码如下（MSVC）：

1
2
3
4
5
6
template<class _Ty> inline
	constexpr typename remove_reference<_Ty>::type&&
		move(_Ty&& _Arg) _NOEXCEPT
	{	// forward _Arg as movable
	return (static_cast<typename remove_reference<_Ty>::type&&>(_Arg));
	}

std::forward<T>(T&& val) 会将val转换成与其传入时相同的类型并将转换后的进行返回，即如果传入时是左值则返回左值，如果传入的是右值则返回右值，实现代码（MSVC）如下：

1
2
3
4
5
6
template<class _Ty> inline constexpr _Ty&& forward(
typename remove_reference<_Ty>::type&& _Arg) _NOEXCEPT
	{	// forward an rvalue as an rvalue
	static_assert(!is_lvalue_reference<_Ty>::value, "bad forward call");
	return (static_cast<_Ty&&>(_Arg));
	}

使用方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void fun(int &x) { cout << "lvalue ref" << endl; }  
void fun(int &&x) { cout << "rvalue ref" << endl; }  
void fun(const int &x) { cout << "const lvalue ref" << endl; }  
void fun(const int &&x) { cout << "const rvalue ref" << endl; }  
  
template<typename T>  
void PerfectForward(T &&t) { fun(std::forward<T>(t)); }  
  
int _tmain(int argc, _TCHAR* argv[])  
{  
    PerfectForward(10);           // rvalue ref  
  
    int a;  
    PerfectForward(a);            // lvalue ref  
    PerfectForward(std::move(a)); // rvalue ref  
  
    const int b = 8;  
    PerfectForward(b);            // const lvalue ref  
    PerfectForward(std::move(b)); // const rvalue ref  
  
    system("pause");  
    return 0;  
}

完美转发涉及到了引用折叠规则(reference collapsing rule), 以及一个特殊原则，在 2.两个原则 中有讲到，这两个原则应当归属在 模板 的新增特性里。

注意：为了避免这两个原则对我们造成思维混乱，将其归为 完美转发 ，并使用完美转发来解决根据输入的左值或右值调用参数为左值或右值的重载函数。 若要使用上述原则，则需要进行针对性的测试，并能根据实际情况测试出能得到自己想要的结果的使用方法才可以使用。

右值引用使用注意

  • 对于将亡值，如果对象能够调用 移动构造函数 和 移动赋值函数，则会自动使用 移动语义， 因此，对于右值引用在函数返回值方面，最佳使用方法是：

    1
    2
    3
    4
    5
    6
    7
    std::vector<int> return_vector(void)
    {
        std::vector<int> tmp {1,2,3,4,5};
        return tmp;
    }
    std::vector<int> rval_ref = return_vector();

    与我们之前写的函数并无其他特殊之处。

  • 无论是左值引用 & 还是右值引用 &&，本质上都是 引用类型（是一种基本类型），以前使用 & 会导致的错误的地方，把 & 替换成 && 也会出现错误。

    错误使用 && 和 &的方法如下，该方法返回的对象临时的，在返回完成之后会被析构，导致引用指向错误，运行错误：

    1
    2
    3
    4
    5
    6
    7
    std::vector<int>&& return_vector(void)
    {
        std::vector<int> tmp {1,2,3,4,5};
        return std::move(tmp);
    }
    std::vector<int> &&rval_ref = return_vector();
    1
    2
    3
    4
    5
    6
    7
    std::vector<int>& return_vector(void)
    {
        std::vector<int> tmp {1,2,3,4,5};
        return tmp;
    }
    std::vector<int> &rval_ref = return_vector();

  • 如何使用右值引用，与上面同理，右值引用也是一种 引用类型，以前为了传参数避免参数调用复制构造而使用 & 传引用的地方，或者返回一个非函数内创建的变量的引用而是用 & 的地方，都是可以使用右值引用 && 的地方。

    && 与 & 的声明方法相同，只能在声明右值引用的同时必须指定一个引用对象。示例如下：

    1
    2
    3
    4
    5
    6
    MyString& reference(MyString& v) {      // & 引用在参数、返回值上的应用
        std::cout << "左值引用" << std::endl;
        return v;
    }
    MyString c;
    MyString& d = reference(c);
    1
    2
    3
    4
    5
    6
    int&& reference(MyString&& v) {         // && 引用在参数、返回值上的应用
        std::cout << "左值引用" << std::endl;
        return std::move(v);                // 注意：这里需要将左值v转换成右值
    }
    MyString c;
    MyString&& d = reference(std::move(c)); // 注意：这里需要将左值c转换成右值

  • 上述函数返回引用类型的用法很少用到，如需用到需要参考 输入输出流 的>> 或 << 运算符的写法。我们经常用到的是在函数参数上声明引用类型，如 reference(MyString& v), 如果我们要使用 移动语义 对某一对象要将其移动函数内进行操作，则可有如下写法：

    1
    2
    3
    4
    5
    6
    int&& reference(MyString&& v)  {        // && 引用在参数、返回值上的应用
        MyString&& tmp = std::move(v);
        ...                                 // op for tmp
        ...                                 
        return std::move(tmp);              // 注意：这里需要将左值v转换成右值
    }

而实际上，我认为在使用移动语义的时候配合 完美转发(Perfect Forwarding) 则能够使函数提供更多的用法，典型用法可参考 vector 的 void push_back(value_type&& _Val)。可我怎么觉得我很少能用到

何时发生移动，何时发生复制

在实际程序设计时，我们需要知道何时是调用 复制构造函数 与 复制赋值函数，何时调用 移动构造函数 与 移动赋值函数。下面是一个我抄的(出处在最后的链接上)一个类的写法，上面粗体的四个函数都有实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class MyString {
private:
    char* _data;
    size_t   _len;
    void _init_data(const char *s) {
        _data = new char[_len + 1];
        memcpy(_data, s, _len);
        _data[_len] = '\0';
    }
public:
    MyString() {
        _data = NULL;
        _len = 0;
    }
    MyString(const char* p) {
        _len = strlen(p);
        _init_data(p);
    }
    // 复制构造函数, 标号1函数
    MyString(const MyString& str) { 
        _len = str._len;
        _init_data(str._data);
        std::cout << "Copy Constructor is called! source: " << str._data << std::endl;
    }
    // 复制赋值函数, 标号2函数
    MyString& operator=(const MyString& str) { 
        if (this != &str) {
            _len = str._len;
            _init_data(str._data);
        }
        std::cout << "Copy Assignment is called! source: " << str._data << std::endl;
        return *this;
    }
    // 移动构造函数, 标号3函数
    MyString(MyString&& str) {
        std::cout << "Move Constructor is called! source: " << str._data << std::endl;
        _len = str._len;
        _data = str._data;
        str._len = 0;
        str._data = NULL;
    }
    // 移动赋值函数, 标号4函数
    MyString& operator=(MyString&& str) {
        std::cout << "Move Assignment is called! source: " << str._data << std::endl;
        if (this != &str) {
            _len = str._len;
            _data = str._data;
            str._len = 0;
            str._data = NULL;
        }
        return *this;
    }
    virtual ~MyString() {
        if (_data) free(_data);
    }
};

接下来我们我们进行试验，来了解 移动 和 复制 的调用情况，先给出试验用的测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int main() 
{
    std::vector<MyString> v;
    MyString a0("a0"), a1("a1"), a2("a2");
    a0 = a1;                        // 测试调用 复制
    a0 = std::move(a2);             // 测试调用 移动
    a0 = MyString("a4");            // 测试调用 移动 or 复制
    a0 = creatAnNumString(1000);    // 测试调用 移动 or 复制
    v.push_back(MyString("a5"));    // 测试调用 移动 or 复制
    v.push_back(a0);                // 测试调用 复制
    v.push_back(std::move(a0));     // 测试调用 移动
    
    system("pause");
    return 0;
}

  • 在1, 2, 3, 4都定义的情况下，我们会得到下面的结果：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Copy Assignment is called! source: a1
    Move Assignment is called! source: a2
    Move Assignment is called! source: a4
    Move Assignment is called! source: 1000
    Move Constructor is called! source: a5
    Move Constructor is called! source: a5
    Copy Constructor is called! source: 1000
    Move Constructor is called! source: a5
    Move Constructor is called! source: 1000
    Move Constructor is called! source: 1000

  • 在1,2,3都定义的情况下，我们会得到下面的结果：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Copy Assignment is called! source: a1
    Copy Assignment is called! source: a2
    Copy Assignment is called! source: a4
    Copy Assignment is called! source: 1000
    Move Constructor is called! source: a5
    Move Constructor is called! source: a5
    Copy Constructor is called! source: 1000
    Move Constructor is called! source: a5
    Move Constructor is called! source: 1000
    Move Constructor is called! source: 1000

  • 在1,2都定义的情况，我们会得到下面的结果：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Copy Assignment is called! source: a1
    Copy Assignment is called! source: a2
    Copy Assignment is called! source: a4
    Copy Assignment is called! source: 1000
    Copy Constructor is called! source: a5
    Copy Constructor is called! source: a5
    Copy Constructor is called! source: 1000
    Copy Constructor is called! source: a5
    Copy Constructor is called! source: 1000
    Copy Constructor is called! source: 1000

  • 在只定义1的情况下，我们得到了一个运行错误的结果.在Debug的过程中，a0 = MyString("a4"); 在运行时并未调用标号1函数，那没有调用 复制构造函数 则调用是使用了移动的 移动赋值函数 。

  • 在我们定义了1,3,4的情况下，我们得到如下结果:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Copy Assignment is called! source: a1
    Move Assignment is called! source: a2
    Move Assignment is called! source: a4
    Move Assignment is called! source: 1000
    Copy Constructor is called! source: a5
    Copy Constructor is called! source: a5
    Copy Constructor is called! source: 1000
    Copy Constructor is called! source: a5
    Copy Constructor is called! source: 1000
    Copy Constructor is called! source: 1000

    本次的输出，告诉我们第三句调用的是 移动赋值函数。

  • 在1,2,3,4都未定义的情况下，我们在析构函数的时候，得到了一个运行错误，而析构函数做的是 delete 操作。

上述输出结果告诉我们，要想像 main() 函数中那样调用，并且想得到自己最理想的调用结果，就需要自己设计能用的复制构造函数 与 复制赋值函数，以及 移动构造函数 与 移动赋值函数 或者 遵照C++新标准的推荐，避免使用C风格的指针 。

上述代码可能是使用了C风格的指针，导致在移动赋值函数调用之后，出现问题，本句存疑，容我之后好好想想。

在这里解释一下为什么7行代码却输出了10行输出，原因在于 vector 身上，众所周知，vector 是一个动态数组，其内部的数据是连续存放的，因此，当 vector 每增加一个元素就需要判断一下vector的大小是否已经达到目前分配的最大数量，如果达到了最大数量则需要先申请一个更大的数组，然后将现在的元素 移动 或者 复制 到新的数组中进行存储，然后将新的元素追加到当前数组的最后位置。

注意：一个类型如果明确它是可以移动的，则一定要显式定义它的 移动构造函数 与 移动赋值函数，若是明确它是可以拷贝的，则一定要显式定义它的 复制构造函数 与 复制赋值函数, 如果明确它不可以移动或者拷贝，则将其 私有化 即可封闭相应的函数调用。

注意：涉及到新特性，需要进行针对特性的测试。

感谢

本文抄袭了他们的一些原文，如果作者禁止使用，则请告知，我会第一时间修改。

展开全文 >>

关于字符编码的理解

为什么要写这个东西

今天要写的一个小程序用来合并几十个文本文件，然后呢我本以为用C++半小时就可以搞完了，但没想到合并VS工程的xml格式的配置文件总是出现一些方块乱码(长得就像扑克牌的方块一样)。
百撕不得骑姐，于是我准备晚上回来仔细查一查然后写个总结。当然，充实自己的博客也是个主要目的。

字符，字符集，字符编码的联系

这三者的定义：

字符（Character）是指计算机中使用的字母、数字、字和符号，包括：1、2、3、A、B、C、~！·#￥%……—*（）——+等等, 是类字形单位或符号的基本信息。

字符集(Character set)是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集名称：ASCII字符集、GB2312字符集、BIG5字符集、 GB18030字符集、Unicode字符集等。

字符编码（英语：Character encoding）也称字集码，是把字符集中的字符编码为指定集合中某一对象（例如：比特模式、自然数序列、8位组或者电脉冲），以便文本在计算机中存储和通过通信网络的传递。常见的例子包括将拉丁字母表编码成摩斯电码和ASCII。

在计算机技术发展的早期，如ASCII（1963年）和EBCDIC（1964年）这样的字符集逐渐成为标准。但这些字符集的局限很快就变得明显，于是人们开发了许多方法来扩展它们。对于支持包括东亚CJK字符家族在内的写作系统的要求能支持更大量的字符，并且需要一种系统而不是临时的方法实现这些字符的编码。

于是出现了 ANSI，GB2312，GBK，Big5， Unicode（与UCS字符集关系密切），UTF-8，UTF-16，UTF-32，Base64等等。

更加详细且清楚的解释请移步Jim Liu的《编码歪传——基础篇》。

一般处理字符的工作流程

推荐使用UTF-8来进行字符存储，但由于很多系统或者软件会产生一些使用其他字符编码的文件，比如我经常用的VS 2013的代码文件中的中文注释在UTF-8下都是乱码，这时候需要转换到GBK进行读取才可以正常显示。

因此，我们进行字符处理的流程需要先判断一下文件使用什么编码，然后将其转换成Unicode，再将其转换成需要的编码（比如把字符显示的数字转换成二进制的数字排在一起）进行存储。

如何判断一个文件的编码格式：首先判断是否是带BOM的UTF-8格式，如果是，则前三个字节为 EF BB BF 。
关于BOM：

BOM（Byte-Order Mark，字节序标记）是Unicode码点U+FEFF。它被定义来放在一个UTF-16文件的开头，如果字节序列是FEFF那么这个文件就是大端序，如果字节序列是FFFE那么这个文件就是小端序。UTF-8本身是没有字节序的问题的（因为它是以单个字节为最小单位），但是Windows里面很多编辑器（比如记事本）会多此一举的在UTF-8文件开头加入EF BB FF也就是U+FEFF的UTF-8编码。

如果不是带BOM的UTF-8格式，则需要判断所有的字节是否符合UTF-8的字节规定：

  • 1字节：0xxxxxxx
  • 2字节：110xxxxx 10xxxxxx
  • 3字节：1110xxxx 10xxxxxx 10xxxxxx
  • 4字节：11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

如果出现非法字节则不是UTF-8，那读取则依系统情况而定了。同样的，判断其他字符编码也是可以通过寻找非法字符来判断。但即便是没找到非法字符也不一定说明该文件一定是该字符编码。

对于网络传输来说，最好不同端都约定好默认编码格式。UTF-8兼容ASCII编码，而ASCII是传输英文效率最高的一种，所以一般约定为ASCII编码。

我碰到的问题

带BOM格式的UTF-8的读取：无论用C++字符流还是字节流读取文件后，总是有些字符是乱码，原因已经找到，感谢Jim Liu的文章《编码歪传——番外篇》为我解惑。我读取的有些文件是带BOM标记的，而我讲这些文件的所有字符都存到同一个文件中，就会发现这些BOM是乱码，明天就把这几个字符删掉去。

我们采用xml配置的软件dll调用接口，一旦用文本文档打开后，再关闭就发现解析错误，之前发现文本文档会添加三个字符，于是删掉时候就可以正常解析了。这个问题原因就是我们的解析代码并没有针对BOM进行处理。也就这样吧，我又没权限修改代码，技术总监是傻逼And顽固不化And异想天开And瞎指挥又没将所有代码开放给我们这些开发人员。sad…

记录：一些编码应注意的事项

待补吧……

展开全文 >>

搭建github.io静态博客遇到的问题

为什么我需要一个博客

很早之前ACM训练时在CSDN上开过一个博客，经常将自己的题解贴到上面去，可惜这个习惯并没有坚持太久(是懒病犯了……)。
现在毕业差不多半年了，感觉需要将最近看到的东西以及以后看到的东西总结总结，写写读书笔记，最近看C++感觉记忆力不够用了。

想去买个VPS，接触过Node.js之后，又想过自己试着写一个，虽然自我感觉很不错(年轻人经常自大……)，但由于本人是写C++的，
虽然学会了TypeScript但从来没怎么用过，随着时间(当然是逐渐忘了……)流逝，各种框架一个版本一个版本地更新，真没时间去练习……

但后来，我觉得不能这么悠闲得生活下去，得提高自己的知识水平才行，说不定出现什么不幸的事件，那只得靠自己了。

今天刷知乎时，看到
教你免费搭建个人博客，Hexo&Github —— 崔斯特的博客
，感觉可行啊，那就自己搭一个~~

搭建Github.io博客的原理

简单了解了一下，Github的域名分为两个: github.com 和 github.io，
不同的域名可以采用不同安全策略，保证托管在Github上的代码不会因为Cookie被利用而遭到破坏；
数据做了划分处理，可以放到不同的服务器上进行保存，比较容易进行分流等等。

github.io可以将代码仓库中的静态网页渲染到浏览器上，因此，
创建一个xxx.github.io仓库然后在里面存贮博客的静态网页，
如此我们就可以使用 https://yourname.github.io/ 就可以访问自己的博客，浏览文章内容了。

搭建Gihub.io博客的工具

这世界上有很多生成静态网页的程序可以用来搭建博客，我用的是 Hexo ， 官方网站在这里。
这是一个使用Node.js写出来的工具，有这么几个优点：

  • 超快速度：Node.js 所带来的超快生成速度，让上百个页面在几秒内瞬间完成渲染。
  • 支持 Markdown：Hexo 支持 GitHub Flavored Markdown 的所有功能，甚至可以整合 Octopress 的大多数插件。
  • 一键部署：只需一条指令即可部署到 GitHub Pages, Heroku 或其他网站。
  • 丰富的插件：Hexo 拥有强大的插件系统，安装插件可以让 Hexo 支持 Jade, CoffeeScript。(我相信也一定支持TypeScript)

这之后，为了让自己的博客变得更好看一些，我使用了主题 NexT , 官方网站在这里。
这个主题应该是使用人数最多的主题，在github上的star数超乎想象，而且还有完善的中文文档可供阅读。

写博文完善自己的博客

Hexo 支持 Markdown，但Markdown至今也没有几个称得上完美的编辑器，我使用的是微软家的 VSCode ，
VSCode 支持基础的 Markdown 语法，但如果希望支持更多的语法，你需要安装 VSCode 的插件，或者自己造一个。
正宗完善的 Markdown 可以支持很多东西，比如流程图，各种各样的表格，LaTeX等，如果用不到或者不想费劲学习，
则使用图片就可以了。

我推荐的 Markdown 语法查询目录，是 SegmentFault 的 Markdown语法编辑器指南。
这份指南足以满足大部分博客写作的要求了。

我碰到的问题

  • 1，Hexo 部署失败，导致部署失败的原因有这几个：
    • 网络环境差，导致无法push到github的博客仓库里，多执行几次 "hexo deploy" 命令可能就成功了；
    • 解析出现错误，这种问题经常是配置文件写错了字母，或者在md文档中用错了Hexo的标签，查看终端输出的信息很容易发现问题的所在；
    • git工具未找到，这种问题一种是安装了git，但环境变量没有配置成功，另外一种就是没有安装，这个时候应该回到Hexo的使用文档中查看自己漏掉了哪些步骤。
  • 2，Hexo 解析的网页不显示图片，或者在主页中显示而在单独一篇文章中未显示：
    • 这个是由于 Markdown 解析路径的问题，Hexo 的作者们好像并没有到Markdown解析中解决这个问题，虽然他们提出使用 相对路径引用的标签插件 ， 但我并没有使用成功，我的解决方法是安装了 Node.js 的 hexo-asset-image 模块，可以通过 npm install hexo-asset-image --save 来进行安装和使用。
  • 3，我试图向 xxx.github.io 存放文件，却发现经常被 Hexo 删掉，这个需要注意一下。本打算将 Hexo 程序和博客原文一同放到 xxx.github.io中，看来是不行了，只好新建了一个库。
  • 4，每次更新之后，最好是用 hexo clean 清理一下，防止发生一些错误。

    我的一些想法

应该利用空余时间研究下怎么样完善自己博客的功能，比如增加相册(图片应该找个图片云存放)等，写个主题什么的。

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

需要组织……<br><br>一起看动漫，一起刷代码<br>Constact Me!