c++函数引用

由于使用c++太少，在项目中定义成员函数时，想着应该返回vector<string>&还是vector<string>；思考上升到函数返回对象时，经历几次构造函数。

依稀记得函数返回对象，需要经过生成一个临时对象(call copy constructor)，然后根据语句是变量声明还是复制分别调用copy constructor 或者assign operator；

分别使用g++(4.84.xx)和VS2010+实验以下code:

#include "stdafx.h"
#include <stdlib.h>
#include <vector>
#include <iostream>
using namespace std;
class A {
public:
    int a;
    A() :a(10) {}
    ~A()
    {
        //printf("~A(),addr=%p\n",this);
    }
    A(const A& inst)
    {
        printf("copy constructor\n");
        this->a = inst.a;
    }
    A& operator =(const A& inst)
    {
        printf("operator =\n");
        this->a = inst.a;
        return *this;
    }
    int& getA()
    {
        return a;
    }
};
A func()
{
    A a;
    a.a = 3;
    printf("func() a.a addr=0x%p\n", &a.a);
    return a;
}
int main()
{
    printf("test A a = func()\n");
    A a = func();
    A a1 = func();
    printf("a.a,a1.a addr=0x%p, 0x%p\n", &a.a, &a1.a);
    //A& b = func();//intial value of reference to non-const must be a lvalue
    int& c = a.getA();
    a.a = 100;
    printf("%d\n",c);
    A* b = new A();
    int& c1 = b->getA();
    b->a = 100;
    printf("delete before %d\n", c1);
    delete b;
    printf("delete after %d\n", c1);
    system("pause");
    return 0;
}

1、结果发现，在release版本(准确的说法是打开了优化项)，A a = func();这种形式被编译器优化，不会调用copy constructor，即使a=func()也只有一次assign operator(不管是否打开优化选项)；

禁止优化项，得到的结果，A a = func();调用一次copy constructor。

2、另外考虑一个对象的成员函数什么时候应该使用引用返回成员变量呢？

百度搜索，找不到想要的解答；自己思考，引用返回成员变量，会导致它的作用域发生变化，如果对象被释放，可能引起资源被释放还在使用的问题(例如野指针)；

因此，我觉得可以使用引用返回例如vector<string>的对象，但开发者应该注意使用者和对象的生存周期(string.data()/c_str()就是这个意思)；另外在提供对外api时，如果使用引用对象返回的形式，一定需要注明该对象的生命周期。

期望有大神可以对这个问题提出经验之谈，本人实在缺乏经验。标准库给出了例子(string)，写code大局上遵守低耦合高内聚，易调试，易扩展(框架，灵活性)；细处能通就是赢，鬼斧神工的细节是修改出来的不是写出来的。

以下是打开优化时，VS2017的输出结果(gcc的%p会自动加上0x)：

test A a = func()
func() a.a addr=0x0034FAD4
func() a.a addr=0x0034FAD0
a.a,a1.a addr=0x0034FAD4, 0x0034FAD0
100
delete before 100
delete after 7171672

3、引用做入参的有趣发现

写函数时，如果不想发生constructor，总会想到引用(&)，如果觉得入参不需要被修改，总会想到const，加与不加的区别，我认为只有入参可变或不可变， 没有其他区别；

因为懒，不写const，会导致有时传参不那么方便(cahr*传给const string&)：

在做一个项目时，发现其他一点东西：入参加上&，如果带上const，那么支持隐式类型转换；

void testIntRef(int& ref)
{
	;
}
void testConstIntRef(const int& ref)
{
	;
}
void testInt(int i)
{
	;
}
void testConstInt(const int i)
{
	;
}
void testRef()
{
	int test = 3;
	testIntRef(test);
	testConstIntRef(3);
	char a = 'a';
	//testIntRef(a);//compile error
	testConstIntRef(a);//implict convert
	testInt(a);
	testConstInt(a);
}
声明函数时，面对string（实参传入char*），或者一些自定义类时，了解这点挺重要吧！