c++下标运算符到下级类向量

c++ subscript operator to underling class vector

本文关键字：向量 下标 运算符 c++      更新时间：2023-10-16

所以我正在尝试创建一个vec类，稍后可以对其进行vec数学运算。

在我开始实施实际程序之前一直工作得很好。

类别vecn:

#include <vector>
template <typename T>
class vecn
{
public:
vecn() {    }
template <typename... Args>
vecn(Args&&... args)
{
addtovector(args...);
}
friend std::ostream& operator<<(std::ostream& os, const vecn<T>& obj)
{
os << "{";
for (auto it = obj.contents.begin(); it < obj.contents.end(); it++) {
os << *it;
if (it != obj.contents.end() -1)
{
os << ",";
}
}
os << "}";
return os;
}
template<typename T>
vecn<T>& operator=(const vecn<T>& v) {
contents = v.contents;
return *this;
}
unsigned int size() const
{
return contents.size();
}
vecn<T> operator+(const vecn<T>& v1) {
vecn<T> v2();
for (unsigned int i = 0; i < size();i++)
{
v2[i] = v1[i] + this->contents[i];
}
return v2;
}
T& operator[](size_t Index)
{ 
if (Index > contents.size() -1)
{
contents.resize(Index + 1);
}
return contents.at(Index);
}
const T& operator[](size_t Index) const
{
return contents.at(Index);
}
private:
template <typename... Args>
void addtovector(T& first, Args&&... args)
{
addtovector(first);
addtovector(args...);
}
void addtovector(T& item)
{
contents.push_back(item);
}
std::vector<T> contents;
};

现在我遇到了一个问题，使用下标运算符来加速下属向量，无论我如何设计它，它都无法正常工作。通常导致

Error   C2109   subscript requires array or pointer type

通过谷歌搜索这个错误，我应该返回一个指向带下标的数组的指针。我是这样做的。

我缺了什么吗？

main：

vecn<int> v(1,2);
vecn<int> b(3, 4, 5);
std::cout << v + b;

预期输出：

{4,6,5}

GCC告诉我到底出了什么问题：

error: declaration of template parameter ‘T’ shadows template parameter

(针对您的任务操作员(

然后：

warning: pointer to a function used in arithmetic [-Wpointer-arith]
v2[i] = v1[i] + this->contents[i];

(您已经将v2声明为返回vecn<T>的函数，请删除括号(

最后，修复您的operator+，因为它将尝试访问空v2向量的元素，并在v1和this->contents的大小不相等的情况下访问它们中较小的一个。

在我看来，你为这么简单的事情写了很多不必要的代码。您不需要addtovector，只需扩展参数包，如：

contents{std::forward<Args>(args)...}

在成员初始值设定项列表中。您根本不需要定义operator=，由编译器决定。并尝试在operator+=的基础上实现operator+。

尽管有其他事情，你的代码中有一个相当令人毛骨悚然的东西

if (Index > contents.size() -1)

永远不要用算术运算来代替布尔运算符的正确选择！std:：vector<>。size((返回size_t(在大多数系统中为无符号长(，只有您自己制作的size((会返回int，这是不应该的，因为负大小没有意义。

现在0-1不会产生一个0是size_t的负数，而是一个huuuge:18446744073709551615(0xffffffffff(。

因此，对于size((=0

if (Index > contents.size() -1)

永远不会是真的，并且在访问vec[0]时，你的vec不会像你想要的那样增长。只需使用

if (Index >= contents.size())

这正是你的意思。

您的问题可能是使用了vecn<T> v2();而不是vecn<T> v2;，但您的解决方案中还有其他不好的地方。以下是一些重构：

template <typename T>
class vecn {
public:
vecn() {}
template <typename... Args>
vecn(Args&&... args)
{
addToVector(args...);
}
friend std::ostream& operator<<(std::ostream& os, const vecn<T>& obj)
{
os << "{";
for (auto it = obj.contents.begin(); it < obj.contents.end(); it++) {
os << *it;
if (it != obj.contents.end() - 1)
os << ",";
}
os << "}";
return os;
}
// you don't need this
// template<typename T>
// also whole method is unnecessary
//    vecn<T>& operator=(const vecn<T>& v)
//    {
//        contents = v.contents;
//        return *this;
//    }
// use size_t
/*unsigned int*/ size_t size() const
{
return contents.size();
}
vecn<T> operator+(const vecn<T>& other) const
{
vecn<T> result;
size_t resultSize = std::max(other.size(), size());
result.contents.reserve(resultSize);
for (size_t i = 0; i < resultSize; ++i) {
T value = {};
if (i < other.size())
value += other.contents[i];
if (i < size())
value += contents[i];
result.contents.push_back(value);
}
return result;
}
T& operator[](size_t index)
{
return contents.at(index);
}
const T& operator[](size_t index) const
{
return contents.at(index);
}
private:
template <typename... Args>
void addToVector(T& first, Args&&... args)
{
addToVector(first);
addToVector(args...);
}
void addToVector(T& item)
{
contents.push_back(item);
}
std::vector<T> contents;
};
相关文章：