为什么在我的函数类型后使用引用运算符 (&) 允许我修改它返回的值？

我正在创建我自己版本的向量容器(以STL向量容器为模式(，遇到了一个有趣的问题。我希望能够使用.at((函数为我的向量赋值，比如：

vector<int> myVec1 = {1, 1, 3, 4};
myVec1.at(1) = 2; //assigning a value using .at()

所以我做了一些实验，我发现如果我把.at((函数做成这样：

template <typename Type>
Type& My_vector<Type>::at(int const index) {            //notice the ampersand(&)
return *(array + index);
}

那么我就可以像在STL向量类中一样赋值了！我打感叹号是因为对我来说，这是一个惊喜。我的想法是；运算符将返回给定索引处的值的地址，并执行以下操作：

My_vector<int> myVec1 = {1, 1, 3, 4};
myVec1.at(1) = 2;

将myVec1的第二个元素的地址设置为2。然而，情况并非如此，相反，它会更改那里的值。这对我来说很好，因为我的目标是能够使用.at((赋值，但我的问题是，当我说这个函数应该在此时返回值的地址时，我的想法有什么缺陷？我的函数定义中的"与"运算符实际上是如何在这里工作的？我能说"它正在返回对给定索引处数组值的引用吗？"这似乎就是正在发生的事情，但哇，我认为我很好地掌握了&和*操作员在大多数情况下工作。下面是一个功能齐全的示例：

My_vector.h

#ifndef My_vector_h
#define My_vector_h
#include <cstring>
#include <type_traits>
#include <initializer_list>
template <typename Type>
class My_vector {
private:
Type* array;
int vector_size;
public:
//Copy Constructor
My_vector(std::initializer_list<Type> list) {
array = new Type[list.size() + 10];
vector_size = list.size();
memcpy(array, list.begin(), sizeof(Type) * list.size());
}
//Destructor
~My_vector() {delete [] array; array = nullptr;}
//Accessor .at()
int size() {return vector_size;}
Type& at(int const);
};
template <typename Type>
Type& My_vector<Type>::at(int const index) {
return *(array + index);
}
#endif /* My_vector_h */

main.cpp

#include <iostream>
#include "My_vector.h"
int main() {
My_vector<int> sampleVec = {1, 1, 3, 4};
for (int i = 0; i < sampleVec.size(); i++) {
std::cout << sampleVec.at(i) << " ";
}
std::cout << std::endl;
sampleVec.at(1) = 2;
for (int i = 0; i < sampleVec.size(); i++) {
std::cout << sampleVec.at(i) << " ";
}
std::cout << std::endl;
return 0;
}

输出：

1 1 3 4 
1 2 3 4