stdvector 相关问题

有没有办法通过构造函数体将对象添加到向量？

所以我对 C++ 和一般编程很陌生，在我的一些作业中，我需要存储我在向量中创建的对象，我总是使用这种方法： std::vector 类；

为什么STL容器没有通用函数的方法？

我知道迭代器上有一些通用函数可以完成您想要做的所有事情，例如 std::find、std::count 等，但为什么标准容器（例如 std::vec）不可以呢？ .

使用初始值设定项列表放置向量

我有一个 std::vector> 并想在其末尾添加一些元素，所以这是我的尝试： std::vector > vec; vec.emplace_back(...

是否必须有一个函数模板来传递 std::vector 作为参数？

是否必须有一个函数模板来将 std::vector 作为参数传递，如下面的代码所示？ 另外，在参数中，为什么我们需要将 与 std::vector 一起传递？ 模板 是否必须有一个函数模板来将 std::vector 作为参数传递，如下面的代码所示？ 还有，在参数中，为什么我们需要和<T>一起传递std::vector？ template <typename T> void print_vec(const std::vector<T>& vec){ for(size_t i{}; i < vec.size();++i){ std::cout << vec[i] << " "; } std::cout << std::endl; } int main(){ //Constructing vectors std::vector<std::string> vec_str {"The","sky","is","blue","my","friend"}; std::cout << "vec1[1] : " << vec_str[1] << std::endl; print_vec(vec_str); } 不，这不是强制性的。作者认为模板 print_vec 比特定于 print_vec 的 std::vector<std::string> 更有用。 注意在 C++20 中您可以使用此语法， 它基本上将您的模板限制为任何“可迭代”的内容 它还表明，在范围（向量）的情况下，你确实应该 使用基于范围的 for 循环。 （遗憾的是，大多数 C++ 课程都有些过时了，并且没有向您展示这一点） #include <vector> #include <ranges> #include <iostream> // Use C++20 template/concept syntax auto print_all(std::ranges::input_range auto&& values) { for(const auto& value : values) { std::cout << value << "\n"; } } int main() { std::vector<std::string> values{"1","2","3"}; print_all(values); }

在 C++ STL 中是否必须有一个模板函数来将向量作为参数传递？

是否必须有一个函数作为模板来传递向量作为参数，如下面的代码所示？ 另外，在争论中为什么我们需要传递 std::vector ？ （我正在学习的基本问题...

std::ranges::transform_view::iterator 不是一个InputIterator吗？

我有以下代码（https://godbolt.org/z/K7sPbjjKE）： #包括 #包括 #包括 std::vector 字段； 无效 insert_many(std::s...

为什么这个循环总是返回 0 作为第一个元素？

我正在尝试创建一个函数来获取间隙内的第一对素数。 我首先创建一个向量并将其大小设置为“m”和“n”之间的差值。 不过，我还是保留了

使用 std::vector::insert 将字符串插入 uint8_t 向量中，将随机数据放入其中

我正在将数据序列化为 uint8_t 向量，以将其发送到另一个模块，我有一个从函数 getVal() 返回的字符串，当我执行 vector.insert() 时，它会显示随机 vals 更多 int。 ..

存储在 std::map/std::set 与存储所有数据后对向量进行排序

语言：C++ 我能做的一件事是分配一个大小为 n 的向量并存储所有数据 然后使用 sort(begin(),end()) 对其进行排序。不然我可以继续放 地图或集合中的数据已排序...

如何清理 std::vector<int*> 而不会出现 _CrtDumpMemoryLeaks() 报告的内存泄漏

我遇到了一个问题，即我无法正确释放内存。我有一个 int* 类型的向量并且 分配内存并将这些指针添加到我的向量后，我只想释放

标准库向量内存泄漏

我遇到了一个问题，即我无法正确释放内存。我有一个 int* 类型的向量并且 分配内存并将这些指针添加到我的向量后，我只想释放

过滤容器的现代方法是什么？

我想知道现代的 - 阅读：C++11 - 过滤数组的方法是什么，即我们如何实现类似于此 C# Linq 查询的东西： var FilteredElements = elements.Where(elm => ...

C++20 std::vector 比较奇怪的行为

为自定义类 T 重载运算符 bool() 会破坏 std::vector 比较运算符。 以下代码在第一个在线编译器上尝试过，谷歌建议我打印 v1 > v2：0 维...

如何在 GPU 上复制 OpenACC 中分配的向量指针内存向量

我正在尝试在 GPU 上复制向量数组的向量。 我尝试使用 OpenACC copyin 子句。 copyin 子句不会复制数组的所有基础数据。当我尝试访问底层 vecto 时...

需要帮助理解“我的程序中的向量大于 max_size()”。 + 如何修复它[重复]

所以对于这个c++程序，我使用zybooks来运行这个程序，这是我之前第一次看到这个错误，但它只是给了我：向量大于max_size()，大于max_size( ）...

为什么 std::vector 的交换函数与所有其他容器的交换函数具有不同的 noexcept 规范？

我注意到 std::vector 容器的交换函数具有与所有其他容器不同的 noexcept 规范。具体来说，如果表达式 std::allocator_tr...

为什么我的迭代器不能使用 std::copy 算法

为什么 MojVektor 中的 Iterator 类（类似于 std::vector）不能与 std::copy 算法一起使用？ MojVektor.hpp #pragma 一次 #包括 #包括 为什么 MojVektor 中的 Iterator 类（类似于 std::vector）不能与 std::copy 算法一起使用？ MojVektor.hpp #pragma once #include <iostream> #include <initializer_list> #include <algorithm> #include <Iterator> template <typename T> class MojVektor { private: size_t capacity_; size_t size_; T* arr_; void realoc() { capacity_ *= 2; T* tempArr = arr_; arr_ = new T[capacity_]; std::copy(tempArr, tempArr + size_, arr_); delete[] tempArr; return; } public: class Iterator; MojVektor() : capacity_{ 10 }, size_{ 0 }, arr_{ new T[capacity_] } {}; MojVektor(const std::initializer_list<T>& list) : capacity_{ list.size() }, size_{ list.size() }, arr_{ new T[capacity_] } { std::copy(list.begin(), list.end(), arr_); return; } MojVektor(const MojVektor& second) : capacity_{ second.capacity_ }, size_{ second.size_ }, arr_{ new T[capacity_] } { std::copy(second.arr_, second.arr_ + size_, arr_); return; } MojVektor& operator=(const MojVektor& second) { capacity_ = second.capacity_; size_ = second.size_; arr_ = new T[capacity_]; std::copy(second.arr_, second.arr_ + size_, arr_); return *this; } MojVektor(MojVektor&& second) : capacity_{ std::move(second.capacity_) }, size_{ std::move(second.size_) }, arr_{ std::move(second.arr_) } { second.capacity_ = 0; second.size_ = 0; second.arr_ = nullptr; return; } MojVektor& operator=(MojVektor&& second) { capacity_ = std::move(second.capacity_); size_ = std::move(second.size_); arr_ = std::move(second.arr_); second.capacity_ = 0; second.size_ = 0; second.arr_ = nullptr; return *this; } ~MojVektor() { delete[] arr_; size_ = 0; capacity_ = 0; return; } MojVektor& push_back(const T& e) { if (arr_ == nullptr) { capacity_ = 10; arr_ = new T[capacity_]; } if (size_ >= capacity_) { realoc(); } arr_[size_] = e; ++size_; return *this; } MojVektor& push_front(const T& e) { if (arr_ == nullptr) { capacity_ = 10; arr_ = new T[capacity_]; } if (size_ >= capacity_) { realoc(); } for (T* endIndex = arr_ + size_ - 1; endIndex >= arr_; --endIndex) { *(endIndex + 1) = std::move(*(endIndex)); } *(arr_) = e; ++size_; return *this; } MojVektor& push_back(T&& e) { if (arr_ == nullptr) { capacity_ = 10; arr_ = new T[capacity_]; } if (size_ >= capacity_) { realoc(); } arr_[size_] = std::move(e); ++size_; return *this; } MojVektor& push_front(T&& e) { if (arr_ == nullptr) { capacity_ = 10; arr_ = new T[capacity_]; } if (size_ >= capacity_) { realoc(); } for (T* endIndex = arr_ + size_ - 1; endIndex >= arr_; --endIndex) { *(endIndex + 1) = std::move(*(endIndex)); } *(arr_) = std::move(e); ++size_; return *this; } size_t size() const { return size_; } T& at(size_t index) const { if (index < 0 || index > size_ - 1) { throw std::out_of_range("Index out of range!"); } return *(arr_ + index); } T& operator[](size_t index) const { return *(arr_ + index); } void clear() { capacity_ = 0; size_ = 0; delete[] arr_; arr_ = nullptr; return; } void resize(size_t newSize, const T& difference_value) { if (newSize < size_) { size_ = newSize; } else if (newSize > size_) { T* tempArr = arr_; capacity_ = newSize; arr_ = new T[capacity_]; std::copy(tempArr, tempArr + size_, arr_); while (size_ < newSize) { arr_[size_] = difference_value; ++size_; } } return; } MojVektor& pop_back() { if (size_ == 0) { throw std::out_of_range("Vector is empty!"); } --size_; return *this; } MojVektor& pop_front() { if (size_ == 0) { throw std::out_of_range("Vector is empty!"); } for (T* beginIndex = arr_; beginIndex < arr_ + size_; ++beginIndex) { *(beginIndex) = std::move(*(beginIndex + 1)); } --size_; return *this; } T& back() const { if (size_ == 0) { throw std::out_of_range("Vector is empty!"); } return arr_[size_ - 1]; } T& front() const { if (size_ == 0) { throw std::out_of_range("Vector is empty!"); } return *arr_; } bool empty() const { return size_ == 0; } size_t capacity() const { return capacity_; } bool operator==(const MojVektor& second) const { if (size_ != second.size_) { return false; } for (size_t i = 0; i < size_; ++i) { if ((this->operator[](i)) != second[i]) { return false; } } return true; } bool operator!=(const MojVektor& second) const { return !(this->operator==(second)); } bool full() const { return size_ == capacity_; } MojVektor subvector(Iterator beginIt, Iterator endIt) const { if (beginIt < begin() || endIt > end()) { throw std::out_of_range("Iterators out of range!"); } MojVektor v; while (beginIt != endIt) { v.push_back(*beginIt); ++beginIt; } return v; } Iterator begin() const { return Iterator(arr_); } Iterator end() const { return Iterator(arr_ + size_); } Iterator find(const T& value) const { Iterator it = begin(); while (it != end()) { if (*(it) == value) { return it; } ++it; } return it; } Iterator erase(Iterator pos) { if (pos < begin() || pos > end()) { throw std::out_of_range("Iterator out of range!"); } if (pos == end()) { return end(); } Iterator it{ pos }; while (it != end()) { *(it) = std::move(*(it + 1)); ++it; } --size_; return pos; } Iterator insert(Iterator pos, const T& e) { size_t index = pos - begin(); if (index < 0 || index >= size_) { throw std::out_of_range("Iterator out of range!"); } if (size_ >= capacity_) { realoc(); } if (index == 0) { push_front(e); } else { for (size_t i = size_; i >= index; --i) { *(arr_ + i + 1) = std::move(*(arr_ + i)); } arr_[index] = e; ++size_; } return Iterator{ arr_ + index }; } Iterator insert(Iterator pos, T&& e) { size_t index = pos - begin(); if (index < 0 || index >= size_) { throw std::out_of_range("Iterator out of range!"); } if (size_ >= capacity_) { realoc(); } if (index == 0) { push_front(std::move(e)); } else { for (size_t i = size_; i >= index; --i) { *(arr_ + i + 1) = std::move(*(arr_ + i)); } arr_[index] = std::move(e); ++size_; } return Iterator{ arr_ + index }; } Iterator rbegin() const { return end() - 1; } Iterator rend() const { return begin() - 1; } Iterator erase(Iterator beginIt, Iterator endIt) { size_t beginIndex = beginIt - begin(); size_t endIndex = endIt - begin(); if (beginIndex > endIndex || beginIndex < 0 || endIndex > size_ || beginIndex > size_) { throw std::out_of_range("Iterators out of range!"); } for (size_t i = beginIndex; i < endIndex; ++i) { arr_[i] = std::move(arr_[endIndex - beginIndex + i]); } size_ -= (endIndex - beginIndex); return Iterator{ arr_ + beginIndex }; } void rotate() { for (size_t beginIndex = 0, endIndex = size_ - 1; beginIndex < endIndex; ++beginIndex, --endIndex) { std::swap(arr_[beginIndex], arr_[endIndex]); } return; } void rotate(Iterator beginIt, Iterator endIt) { size_t beginIndex = beginIt - Iterator(arr_); size_t endIndex = (endIt - Iterator(arr_)) - 1; if (beginIndex > endIndex || beginIndex < 0 || endIndex > size_ || beginIndex > size_) { throw std::out_of_range("Iterators out of range!"); } while (beginIndex < endIndex) { std::swap(arr_[beginIndex], arr_[endIndex]); ++beginIndex; --endIndex; } return; } T* data() { return arr_; } }; template <typename T> std::ostream& operator<<(std::ostream& outputStream, const MojVektor<T>& container) { const size_t size = container.size(); outputStream << "{"; for (size_t i = 0; i < size; ++i) { outputStream << container[i]; if (i + 1 < size) { outputStream << ", "; } } outputStream << "}"; return outputStream; } template <typename T> class MojVektor<T>::Iterator : public std::iterator<std::random_access_iterator_tag, T> { private: T* ptr_; public: Iterator() : ptr_{ nullptr } {}; Iterator(T* ptr) : ptr_{ ptr } {}; Iterator(T& e) : ptr_{ &e } {}; Iterator(const Iterator& second) : ptr_{ second.ptr_ } {}; Iterator(Iterator&& second) : ptr_(std::move(second.ptr_)) { second.ptr_ = nullptr; return; } Iterator& operator=(const Iterator& second) { ptr_ = second.ptr_; return *this; } Iterator& operator=(Iterator&& second) { ptr_ = std::move(second.ptr_); second.ptr_ = nullptr; return *this; } T& operator*() { return *ptr_; } Iterator& operator++() { ++ptr_; return *this; } Iterator operator++(int) { Iterator returnValue{ ptr_ }; ++ptr_; return returnValue; } Iterator& operator--() { --ptr_; return *this; } Iterator operator--(int) { Iterator returnValue{ ptr_ }; --ptr_; return returnValue; } Iterator& operator+=(size_t n) { ptr_ += n; return *this; } Iterator& operator-=(size_t n) { ptr_ -= n; return *this; } Iterator operator+(size_t n) const { return Iterator(ptr_ + n); } Iterator operator-(size_t n) const { return Iterator(ptr_ - n); } T* operator->() { return ptr_; } size_t operator-(const Iterator& second) const { return ptr_ - second.ptr_; } T& operator[](size_t index) const { return *(ptr_ + index); } bool operator==(const Iterator& second) const { return ptr_ == second.ptr_; } bool operator!=(const Iterator& second) const { return !(this->operator==(second)); } bool operator<(const Iterator& second) const { return ptr_ < second.ptr_; } bool operator>(const Iterator& second) const { return ptr_ > second.ptr_; } bool operator<=(const Iterator& second) const { return ptr_ <= second.ptr_; } bool operator>=(const Iterator& second) const { return ptr_ >= second.ptr_; } }; 主.cpp #include <iostream> #include "MojVektor.hpp" #include <algorithm> int main() { MojVektor<int> a{1, 2, 3}; MojVektor<int> b; std::copy(a.begin(), a.end(), b.begin()); std::cout << a << std::endl; std::cout << b << std::endl; return 0; } 我尝试手动设置 iterator_tag、value_type 等，使用 using、using 和继承、typedef 和 typedef 和继承。我还查看了之前提出的一些问题，但它们与列表和插入器相关，也在答案中添加了我的代码中已经存在的继承。 主要是两个问题： std::iterator 类已被弃用，因此在这里建立依赖关系不是一个好主意。 您的 Iterator 类缺少必要的类型别名。 更正这两项后，您的代码将可以编译： template <typename T> class MojVektor<T>::Iterator { private: T* ptr_; public: using iterator_category = std::random_access_iterator_tag; using value_type = T; using difference_type = std::ptrdiff_t; using pointer = T*; using reference = T&; // .... };

如何找到数组中最接近的较小数字？

考虑这个数组： std::vector 数字 = { 0, 4, 12, 60, 89 }; 它已排序并且只有正数。 找到数组中最接近的较小数字的最简单方法是什么，

C++/CLI Winforms。 E2244“托管类的成员不能属于非托管类类型”

我现在正在学习 C++，并尝试创建自定义数据类型 Employee 的向量。 Employee.h代码： 公共参考类员工{ 民众： 系统::字符串^名称； 年龄； 员工（） { ...

OpenMP GPU 卸载向量迭代器

我有这个工作测试代码，它映射 std::vector 以进行卸载并检查计算是否正确： #包括 #包括 int main() { int vec_size = 3; ...