此文作为附属文,单独引出曾困扰我些许时间的问题。。。
问题1:为什么 自定义类型=自定义类型 不会进入自定义类型的赋值重载,而是会进入拷贝构造中
问题2:为什么非const类型可以接收const类型,这不就属于权限放大了吗?
正文在这里:
2023/11/12还在撰写中
这里只把相关的代码贴了出来
vector_copy.h
namespace text {
using std::cout;
using std::endl;
template<class T>
class vector {
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin() {
return _start;
}
iterator end() {
return _end;
}
const_iterator begin()const {
return _start;
}
const_iterator end()const {
return _end;
}
vector() :
_start(nullptr),
_end(nullptr),
_end_of_storage(nullptr)
{}
vector(int n, const T& v = T()) {
_start = new T[n];
_end = _start;
_end_of_storage = _start + n;
while (_end != _end_of_storage) {
*_end = v; //here here----------------------
_end++;
}
}
vector(const vector<T>& v) {//跑到这里
_start = new T[v.capacity()];
_end = _start;
_end_of_storage = _start + v.capacity();
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
}
void swap(vector<T>& v) {
std::swap(_start,v._start);
std::swap(_end,v._end);
std::swap(_end_of_storage,v._end_of_storage);
}
vector<T>& operator=(vector<T> v) {
swap(v);
return *this;
}
size_t size()const {
return _end - _start;
}
size_t capacity() const{
return _end_of_storage - _start;
}
private:
iterator _start = nullptr;
iterator _end = nullptr;
iterator _end_of_storage = nullptr;
};
}
main.cpp
#include<iostream>
#include"vector_copy.h"
using namespace text;
using namespace zxh;
int main() {
vector<vector<int>> ret(1,vector<int>(1,1));
return 0;
}
答:一、
c++中,等号两边都为同种类型时,会调用其赋值重载
这里,here处,往下运行,会跑到拷贝构造处,没有跑到赋值重载
其原因是,它其实进去了赋值重载,只不过我们的赋值重载的参数为形参,没有使用引用,所以要先初始化形参,就会调用拷贝构造,等拷贝构造结束后,自然会进入赋值重载里面去。。。
答:二、
那为什么赋值重载使用 vector<T>& operator=(vector<T> v) 不使用const vector<T> v修饰,可以接收const参数。。。因为这里是形参,而不是引用,引用才不可以这样使用,会导致权限放大,这里是拷贝了一份临时变量,修改临时变量当然不会影响到你传递进来的参数了。。。
只有引用和指针才不允许使用非const类型接收const类型的参数,如果参数为形参,则不受传递参数是否为const影响