c++中有些重载运算符为什么要返回引用？

1. c++中有些重载运算符为什么要返回引用，单单为了避免析构再构造吗？
不是。「有些」重载运算符要返回的引用，是为了返回它本身。如

class TestClass {
    private:
        int number;
    public:
        TestClass& operator+=(const TestClass& rhs) {           // 重载函数返回引用
            number += rhs.number;
            return *this;
        }
};

上例是一个C++的不完整的简单类，其中+=运算符，它本身的意义是「自增，并返回自增后的值」，所以就要返回自己，而不是返回一个自己的拷贝。

2. 在此情况下，返回值为NULL或类似情况怎么办？
引用不可为空，楼主所说的情况不存在。

3. 返回的引用赋给一个变量后，那个变量是不是引用？怎么理解？

#include <iostream>
using namespace std;

class StupidClass {
    int flag;
    public:
        StupidClass(int flag): flag(flag) {
            cout << "Constructor " << flag << endl;
        }
        ~StupidClass() {
            cout << "Destructor " << flag << endl;
        }
        StupidClass(const StupidClass& rhs) {
            cout << "Copy Constructor *this=" << flag << " rhs=" << rhs.flag << endl;
        }
        StupidClass& operator=(const StupidClass& rhs) {
            cout << "Operator = *this=" << flag << " rhs=" << rhs.flag << endl;
            return *this;
        }
        StupidClass& operator+=(const StupidClass& rhs) {
            cout << "Operator += *this=" << flag << " rhs=" << rhs.flag << endl;
            flag += rhs.flag;
            return *this;
        }
};

int main() {
    StupidClass var1(1), var2(2);
    StupidClass var3 = var1 += var2;

    return 0;
}

输出是

Constructor 1
Constructor 2
Operator += *this=1 rhs=2
Copy Constructor *this=3 rhs=3
Destructor 3
Destructor 2
Destructor 3

所以结果就是先执行var1 += var2，然后使用得来的var1对var3拷贝构造。其中var1中的flag变成3了（看后面两个Destructor 3，和Copy Constructor *this=3 rhs=3）。
如果把var3的类型改成StupidClass&，那么输出就变成

Constructor 1
Constructor 2
Operator += *this=1 rhs=2
Destructor 2
Destructor 1

那么var3就是var1的引用了。

4. 据说返回局部对象的引用非常危险， 请问返回引用到底有什么作用？，难道输入输出流返回的不是局部对象的引用？
输入输出流重载的是 << 和 >> 运算符，一般是这样写的

ostream& operator<<(ostream& os, const TestClass& rhs) {
    os << rhs.number;
    return os;
}

这里面没有返回局部对象的引用啊，所谓返回局部对象的引用是像这样的

int& func() {
    int dummy = 1;
    return dummy;
}

在这里dummy就是一个「局部对象」。