參照變數延遲繫結

我們知道參照變數定義時要立刻賦值,告訴編譯器他是誰的參照.如果不賦值,編譯會失敗.
如果參照變數是單個定義的,對他賦值還比較簡單.

struct test_T
{
	int data;
	//...其他成員
	test_T(int _data = 0) :data(_data){}
};

struct SaveTest
{
	test_T & ref;
	//...其他成員
	SaveTest(test_T & _ref) :ref(_ref){}
};

int main(void)
{
	test_T *t   = new test_T[2];
	SaveTest *s = new SaveTest[2]{t[0], t[1]};

	for (int i = 0; i < 2; i++){
		t[i].data = i + 1;
	}

	for (int i = 0; i < 2; i++){
		printf("%d ", s[i].ref.data);
	}
	
	return 0;
}

如果陣列很大.就不方便了.不方便用{}一個一個賦值了.

struct test_T
{
	int data;
	//...其他成員
	test_T(int _data = 0) :data(_data){}
};

struct SaveTest
{
	test_T & ref;
	//...其他成員
	SaveTest(test_T & _ref) :ref(_ref){}
};

int main(void)
{
	test_T *t   = new test_T[2000];
	SaveTest *s = new SaveTest[2000];//沒有用{},編譯直接報錯

	for (int i = 0; i < 2000; i++){
		t[i].data = i + 1;
	}

	for (int i = 0; i < 20; i++){
		printf("%d ", s[i].ref.data);
	}
	
	return 0;
}

我的想法是:先要騙過編譯器,呼叫SaveTest建構函式的時候先賦個預設值,真正的我們用的物件
參照,後面再慢慢賦值給它.

struct test_T
{
	int data;
	//...其他成員
	test_T(int _data = 0) :data(_data){}
};
//******************************增加全域性唯一預設值
test_T default_test(-1);
//******************************
struct SaveTest
{
	test_T & ref;
	//...其他成員               修改建構函式
	SaveTest(test_T & _ref = default_test) :ref(_ref){}
};

int main(void)
{
	test_T *t   = new test_T[2000];
	SaveTest *s = new SaveTest[2000];//編譯ok

	for (int i = 0; i < 10; i++){
		t[i].data = i + 1;
		s[i].ref = t[i];//重新賦值
	}

	for (int i = 0; i < 10; i++){
		printf("%d ", s[i].ref.data);
	}
	
	return 0;
}

輸出:

怎麼會這樣???.(我現在還是不理解)
通過上面的方式,可以做到延遲賦值,但是賦值很奇怪,單個可以被修改,但是所有成員的ref都會一
起被更改,真是秀兒~.
行,那就只能換個思路了.參照不能延遲賦值,指標型別可以吧,我用指標型別.

struct test_T
{
	int data;
	//...其他成員
	test_T(int _data = 0) :data(_data){}
};
//******************************全域性唯一預設值
test_T default_test(-1);
//******************************
struct SaveTest
{
	test_T * ref;
	//...其他成員
	SaveTest(test_T * _ref = nullptr) :ref(_ref){}
};

int main(void)
{
	test_T *t   = new test_T[2000];
	SaveTest *s = new SaveTest[2000];//編譯ok

	for (int i = 0; i < 10; i++){
		t[i].data = i + 1;
		s[i].ref = &t[i];//重新賦值
	}

	for (int i = 0; i < 10; i++){
		printf("%d ", s[i].ref->data);
	}
	
	return 0;
}

哼~,可以了吧.

等一下,等一下,跑題了,雖然這樣做可以,但是不是用的參照實現的啊.
練劍的最高境界就是無劍勝有劍,達到人劍合一,劍既是我,我既是劍.
是時候,讓指標跟參照合二為一啦.

struct test_T
{
	int data;
	//...其他成員
	test_T(int _data = 0) :data(_data){}
};

union MyUnion
{
	test_T * ptr;
	test_T & ref;
	MyUnion(){}
};
struct SaveTest
{
	MyUnion u;
	//...其他成員
	SaveTest(test_T& _ref){
		u.ptr = &_ref;
	}
	
	void set(test_T& _ref){
		u.ptr = &_ref;
	}
	test_T& get(){
		return u.ref;
	}
};

int main(void)
{
	test_T *t   = new test_T[2000];
	SaveTest *s = new SaveTest[2000];//編譯ok

	for (int i = 0; i < 10; i++){
		t[i].data = i + 1;
		s[i].set(t[i]);//重新賦值
	}

	for (int i = 0; i < 10; i++){
		printf("%d ", s[i].get().data);
	}
	
	return 0;
}

使用者角度:
SaveTest *s = new SaveTest[2000];//只是定義變數,沒有繫結
s[i].set(t[i]);//第一次具體賦值,繫結參照(站在使用者角度看)
s[i].get();//得到一個參照
內部:
每次儲存的都是指標,每次使用的時候用參照.

從組合角度,參照和指標,本是一家.
還有,上面那個問題,有興趣的可以試一下,交流交流.