在构造时将C++迭代器的范围连接成const向量成员变量
在构造时将C++迭代器的范围连接成const向量成员变量，可以使用以下方法：
- 首先，需要包含必要的头文件和命名空间：
#include<vector>
#include<iterator>
using namespace std;- 定义一个类，其中包含一个const向量成员变量，并在构造函数中将迭代器的范围连接到该向量：
class MyClass {
public:
MyClass(const vector<int>& input) : my_vector(input.begin(), input.end()) {
}
private:
const vector<int> my_vector;
};在这个例子中，我们定义了一个名为MyClass的类，其中包含一个const向量成员变量my_vector。在构造函数中，我们使用迭代器的范围（input.begin()和input.end()）将输入向量的元素复制到my_vector中。
这种方法可以确保my_vector在构造后不会被修改，从而提高代码的安全性和可靠性。
相关·内容
我想使用不可复制、不可移动类的非默认构造函数来构造向量。使用默认的构造函数，它可以很好地工作，并且我可以构造一个向量，只要我不调整它的大小。但以某种方式使用非默认构造函数，它似乎不得不进行复制。有人知道我是否可以避免使用非默认构造函数在构造过程中复制操作，这样我就可以继续使用向量了吗？
#include <vector>
#include <mutex>
class A {
public:
A(int num) : vec(num) {}
private:
std::vector<std::mutex> vec;
};
浏览 35提问于2022-01-14得票数 2
回答已采纳
我正在学习使用C++向量，但我不能完全理解以下程序的输出：
#include <iostream>
#include <vector>
using namespace std;
class Custom {
public:
int v;
Custom() = delete;
explicit Custom(int v) : v{v} {};
Custom(const Custom &) : v{4} {
}
friend ostream &operator<<(ostream &a
浏览 4提问于2022-03-10得票数 0
回答已采纳
2回答
纵观C++向量文档，pop_back()是一个不会导致向量数据重新分配的函数。但是，这只适用于删除向量的一个成员。我试图找到一种方法从向量的末尾删除多个成员。最初，我以为我会在一个小的for循环中调用pop_back()，但是如果有一个更方便的函数为我这样做的话，我会徘徊吗？
编辑：并不像juanchopanza所指出的那样清晰。这就是我最初使用擦除()放弃的原因。毕竟，擦除效果很好。
浏览 2提问于2014-07-28得票数 6
回答已采纳
7回答
我读到了一些用c++编写的代码，如下所示：
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int iarr[] = {30, 12, 55, 31, 98, 11, 41, 80, 66, 21};
vector<int> ivector(iarr, iarr + 10);
}
在上面的代码中，我将iarr和iarr+10传递给ivector(iarr, iarr + 10)以创建一个新
浏览 0提问于2011-06-22得票数 8
回答已采纳
我使用方法(c++)将一个向量附加到另一个向量：
a.insert(a.end(), b.begin(), b.end());
它可以工作，但是如果b是从成员函数获得的，那么它就不再工作了，比如说
vector<point> const line::returnAVectorOfPoints() const
{
vector<point> pts;
// Do something
return pts;
}
然后这一次，当我试图(像这样)
a.insert(a.end(), returnAVectorOfPoints().begin(), ret
浏览 6提问于2014-02-12得票数 3
回答已采纳
3回答
我正在试着用c++写一个发光二极管条带驱动程序。现在，我有一个Strip类和一个Driver类；Strip类抽象了一个带有几个像素的发光二极管条带，而Driver类将Strip数据聚合到一个缓冲区中，以便通过UDP连接发送。
相关的分部类：
class Strip {
public:
...
??? getPixelData();
int getPixelDataLength();
protected:
std::vector<unsigned char> mPixelData;
class Driver {
public:
.
浏览 3提问于2014-12-19得票数 4
1回答
目标：
把向量包裹起来。包装器可以在部分向量上创建视图。
支持const_view和视图。
视图允许修改元素，而const_view不允许修改元素。
视图是范围(有begin()和end()方法)。
问题：
const_view和视图之间的代码复制。
实际代码实现了一个2D稀疏数组，它比平常节省了更多的内存。所以我想学习如何解决这个问题。
简化代码(实现密集的2D数组)
#include <vector>
class A_csub;
class A_sub;
typedef std::vector<int> V;
typedef typename V::iterato
浏览 0提问于2017-02-03得票数 5
回答已采纳
在c++中将const vector<uint8_t>转换为const vector<char>最有效的方法是什么？
浏览 105提问于2020-06-04得票数 0
编辑:一个新的和改进的版本可以在这个问题中找到，根据反馈！
我需要在没有副本的情况下将一个const引用传递给std::vector的一部分。
一些研究，特别是这个问题，认为它在默认情况下是不受支持的，所以我为它创建了自己的代码：
#include <iterator>
#include <vector>
template <typename T>
class ConstVectorSubrange{
public:
ConstVectorSubrange(typename std::vector<T>::const_iterator st
浏览 0提问于2021-11-21得票数 4
回答已采纳
考虑以下代码：
struct Point {
int x;
int& xref = x;
};
int main() {
std::vector<Point> points;
for (int i = 0; i < 2; i++) {
Point p;
p.x = i;
points.push_back(p);
assert (points[0].x == points[0].xref);
}
return 0;
}
断言在第二次迭代中失败。为什么？
我
浏览 3提问于2017-12-21得票数 2
回答已采纳
1回答
我有一堂课看上去
class Element
{
public :
Element(int im_index, int seg_index)
{
imIndx = im_index;
segIndx = seg_index;
}
Element() { imIndx=-1 ; segIndx=-1; }
void getData( int & toReturnImIndx, int & toReturnSegIndx )
{
toReturnImIndx = imIndx;
浏览 3提问于2014-11-09得票数 0
回答已采纳
在迭代器类型上模板化的迭代器上有我自己的包装器。它工作正常，但当我尝试在算法中使用它时，我将迭代器和向量迭代器混合在一起，就会出现问题。
vector<int> vi{1,2,3,4,5};
auto my_it2 = my_find(vi,2);
cout << *my_it2;// works fine
// but this does not:
vector<int> vi2 (vi.begin(), /*(std::vector<int>::
浏览 0提问于2015-02-15得票数 1
2回答
这是对前一个问题的后续：链表数据结构在C++中的实现。
我试图改进前面代码的设计，方法是修复一些可能超出范围并导致nullptr取消引用的索引，以及为简洁和优雅而做的小改动。然而，我不确定最终的结果(老实说，我很满意，因为这是我在C++工作的第二周)，所以这就是我要求反馈的原因。
#ifndef NYO_UTIL_LINKEDLIST_H
#define NYO_UTIL_LINKEDLIST_H
#include <memory>
#include <iostream>
template <typename T> using ptr = std::sh
浏览 0提问于2016-09-02得票数 3
3回答
考虑下面的代码：
#include <vector>
#include <iostream>
class num{
int a;
int b;
public:
num(int a_, int b_): a(a_), b(b_){}
int Geta(){return a;}
int Getb(){return b;}
};
int main(){
num a(2, 5);
num b(32, 654);
std::vector<num> nums;
nums
浏览 0提问于2016-06-16得票数 1
我对C++相当陌生，并且希望为我的向量实现封装。
#pragma once
#include <vector>
using namespace std;
class Cell {
public:
Cell();
Cell(const Cell& cell);
void setVector(vector<int> vector[]);
vector<int> getVector(void)const;
private:
vector<int> m_vector;
};
我最近读过关于STL迭代
浏览 1提问于2017-04-14得票数 0
回答已采纳
这是对问题的扩展
我读了这篇文章，我确实理解了关于MoveConstructible的解释(或者至少我相信)，但是我不知道为什么，考虑到以下代码：
struct vertex {
const double x;
const double y;
const double z;
};
const std::vector<vertex> test_vertices()
{
std::vector<vertex> vertices;
vertices.emplace_back(vertex(-3.0, -3.0, 0.0));
浏览 2提问于2019-11-24得票数 1
我对面向对象编程很陌生。我正试着做一个叫做“黑帮”的游戏。我使用十六进制对象的静态向量来保存活动游戏(可以有多个活动游戏)。但是每当我尝试将一个新游戏推到十六进制向量，我就会得到一个奇怪的错误：
In file included from /usr/include/i386-linux-gnu/c++/4.8/bits/c++allocator.h:33:0,
from /usr/include/c++/4.8/bits/allocator.h:46,
from /usr/include/c++/4.8/string:41,
浏览 2提问于2020-11-13得票数 0
回答已采纳
这是我的测试程序。变量s1包含一个向量，该向量包含用户定义类型的对象。我想重载<<操作符来很好地打印这个向量，每行一个元素。
#include <iostream>
#include "myclasses.h"
using namespace std;
int main() {
myclass s1;
s1.add_point(7000, 10);
s1.add_point(8000, 11);
s1.add_point(9000, 12);
cout << s1 << endl;
浏览 0提问于2012-03-29得票数 0
回答已采纳
我有一个类声明如下：
class Level
{
private:
std::vector<mapObject::MapObject> features;
(...)
};
在它的一个成员函数中，我尝试迭代这个向量，如下所示：
vector<mapObject::MapObject::iterator it;
for(it=features.begin(); it<features.end(); it++)
{
/* loop code */
}
这对我来说似乎很简单，但g++给了我这个错误：
src/Level.cpp:402:
浏览 1提问于2010-06-15得票数 2
回答已采纳
3回答
在我的C++程序执行过程中，我遇到了一个我不理解的错误(矢量迭代器不兼容)。(Windows / Visual C++ 2008学习版)
这是我的问题的一个简化版本：
#include <vector>
class A
{
int mySuperInt;
public:
A(int val) : mySuperInt(val) {}
};
class B
{
std::vector<A*> myAs;
public:
B()
{
myAs.push_back(new A(1));
浏览 5提问于2010-10-22得票数 1
回答已采纳
2回答
具有构造成员的结构向量
、、、
很多年后，我将回到C++，并且我已经达到了C++17的标准。根据，使用const成员的自定义结构似乎并不总是与没有公共副本分配构造函数的向量兼容。
不过，在我的例子中，与链接问题不同的是，以下内容编译得很好：
#include <vector>
struct Foo { const int m_Bar; };
int main()
{
std::vector<Foo> vecFoos{ Foo{1} };
vecFoos.push_back({ Foo{2} });
return 0;
}
以下几点并没有：
#include <vect
浏览 3提问于2021-06-17得票数 0
回答已采纳
2回答
我是一个专家级的Java程序员，试图将我的知识移植到C++。这不是家庭作业，只是一个概念，我正在努力学习的C++相当于。
我要做的是，使用循环“生成”自定义类型对象的列表。这就是我在Java中所做的：
public class TestClass
{
private ArrayList<ExampleClass> _exampleObjects;
private int _numObjects = 10;
public void populateList()
{
_exampleObjects = new ArrayList<Exampl
浏览 1提问于2013-11-04得票数 7
回答已采纳
10回答
向量迭代器不兼容
、、
我有一个带有std::vector数据成员的类，例如
class foo{
public:
const std::vector<int> getVec(){return myVec;} //other stuff omitted
private:
std::vector<int> myVec;
};
现在，在我的主代码的某个部分，我尝试像这样迭代向量：
std::vector<int>::const_iterator i = myFoo.getVec().begin();
while( i != myFoo.getVec().end())
{
/
浏览 1提问于2011-12-08得票数 43
回答已采纳
1回答
我偶然发现了下面的代码，它在我的脑海中引发了一些问题
std::vector<unsigned char> buf(bytes.constData(), bytes.constData() + bytes.size());
其中bytes is QByteArray和bytes.constData()返回const char*
我检查了向量的构造函数，我认为唯一适合这种描述的构造函数是
vector (InputIterator first, InputIterator last,
const allocator_type& alloc
浏览 1提问于2013-12-01得票数 0
回答已采纳
我正在阅读Bjarne Stroustrup的书The C++ Programming Language，在3.2.4节中，他从一个抽象类开始，演示了一个类层次结构。他的代码看起来像这样：
class Shape
{
public:
virtual Point center()const = 0; //Point is a class defined elsewhere and is unimportant for this question
virtual void move(Point to) = 0;
virtual void draw()const = 0;
浏览 2提问于2015-08-01得票数 0
我对C++相当陌生，并使用std::vector编写了一个多项式类。所有操作都很好，直到我尝试调用函数getCoeff( index)，该函数应该在特定索引处返回系数。在我的例子中，getCoeff(0)应该返回第0系数，即'1‘。
相反，我在用g++编译时会收到此错误：
terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 0) >=this-> size() (which is 0)
浏览 1提问于2018-02-13得票数 0
回答已采纳
4回答
C++自引用类
、、
我不得不承认我的C++有点生疏了。在一个项目中，我尝试创建一个类的向量并使用它们。有一个问题，因为我想用一个唯一的指针来标识向量的每个条目，以便快速访问，但它不起作用。以下是我的问题的一个最小示例：
#include <iostream>
#include <vector>
class Foo{
public:
Foo() { ptr = this; }
~Foo() {}
Foo * ptr;
};
int main()
{
std::vector<Foo> vec;
for(unsigned int i = 0; i < 2; ++i)
v
浏览 0提问于2012-03-09得票数 2
回答已采纳
为什么在这种情况下可以使用私有构造函数？我无法向自己解释。在本例中，我从外部初始化类字段(其类型为同一类)，因为它是静态的。
Edit1：我用C++ 17 (gcc 11.2)。
#include <iostream>
using namespace std;
class MainMenu {
public:
MainMenu(const MainMenu& other) = delete;
MainMenu& operator=(const MainMenu& other) = delete;
static MainMenu&a
浏览 6提问于2021-10-12得票数 4
回答已采纳
3回答
我有一个包含std::vector的类，另一个是该类的自定义iterator。它对于非const方法非常有用，但是当我试图在一个iterator方法中创建一个const时，编译器会失败，因为它不能将一个const_iterator转换成一个iterator。例如，下面的代码失败了，但是如果对ConstFunc的调用被注释掉，它将编译并运行良好。
#include <vector>
template <class T>
class FooIter {
public:
typename std::vector<T>::iterator iterator
浏览 4提问于2020-01-02得票数 2
回答已采纳
来自C#世界的我很难确保我没有在分配给我的C++项目中引入内存泄漏和错误。我正在编写使用structs解析数据缓冲区中的信息的代码。由于缓冲区中出现的数据结构的数量在运行时可能有所不同，所以使用stl向量来存储处理过的数据。我在现有的软件中遇到了以下代码块，并且很难理解它为什么工作：
MyVectorOfObjects.clear();
for (unsigned __int8 i = 0; i < NumberOfObjects; i++)
{
MyParserObject parserObject; // Declaring without &#
浏览 1提问于2011-08-24得票数 8
回答已采纳
我遇到了这个问题:我编写了一个C++类来表示具有给定地址的远程设备(总线上可能有多个设备，每个设备都有不同的地址)。该地址在对象创建时作为构造函数的参数传递给类。类的每个实例都应该有一个不同的地址，如果您试图创建两个具有相同地址的对象，该类应该拒绝它(作为一种单例，但带有一个参数)。我该如何解决这个问题呢？谢谢!
浏览 14提问于2019-02-23得票数 1
回答已采纳
3回答
从方法返回迭代器
、、、
我正在移植一些旧代码。目前，我仍然坚持使用C++ 98标准。我有这个例子：
#include <iostream>
#include <vector>
#include <iterator>
using namespace std;
class ClassPointPrediction {
};
class ClassBuildPointPosition
{
typedef vector<ClassPointPrediction> ClassPointPredictionContainer;
const ClassPo
浏览 5提问于2021-11-15得票数 0
1回答
缩小C++中的二维向量
、、、
我想进入神经网络，这就是为什么我想写我自己的C++矩阵类。问题是，我对C++也很陌生，为了保持简单，我想使用std：：向量而不是2D数组。现在我的课看起来就像
class Matrix {
private:
std::vector<std::vector<float>> data_;
public:
Matrix(const int& rows, const int& columns);
};
我知道std：：向量是有点开销，但我希望保持尽可能小的开销，只将向量缩小到所需的精确大小：
Matrix::Matrix(const in
浏览 0提问于2019-05-05得票数 2
回答已采纳
C++新手来了。我编写了一个函数，它从一个向量返回一个迭代器，我想使用这个迭代器从头到尾遍历这个向量。但是，向量迭代器的使用方式如下
for (auto iterator = vec.begin(); iterator != vec.end(); iterator ++) {
// do something here
}
这意味着我还需要一个vec.end()才能工作。无论如何，我是否只能使用vec.begin()来迭代一个向量，就像我在python中通常所做的那样
for value in some_iterator:
# do something
编辑:一些不相关的更新：
我看到了一些关于
浏览 0提问于2018-07-30得票数 0
回答已采纳
1回答
大约10年前，我对c++编码有一点兴趣，但从未真正爱上过它。但是我现在需要c++来完成我的一个项目(所以我对c++有一点了解，但我不是一个深层次的专家)。我翻阅了我以前的笔记和代码片段，得到了我想要的代码--除了一件事：
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class B
{
private:
string ns;
public:
B(string ms) {ns = ms;}
浏览 1提问于2018-07-30得票数 0
回答已采纳
如何将向量转换/复制到unique_ptr<int[]>？
这就是我想要实现的目标(向量起源于另一个上下文，在复制到unique_ptr后将被删除。unique_ptr是固定长度的，因此可以更有效地分配)。
std::vector<int> vv {1, 2, 3};
struct
U {
U(std::vector<int> v) { // copy constructor
// copy vector v to unique_ptr u, HOW?
}
std::uniq
浏览 2提问于2020-08-25得票数 0
回答已采纳
我需要在for循环中获取要递增的按钮后的数字。例如，button1变成了button2，等等。我尝试添加一个递增的变量，但是Button生成器给出了一个错误消息“C++不是TMain的成员”。有什么方法可以实现最终目标或绕过这个问题吗？
浏览 4提问于2012-07-03得票数 3
回答已采纳
我需要一些关于以下c++语法的解释：
for(const auto& ioDev : deviceList)
鉴于这一点：
std::vector<Device *> deviceList
具体来说，我对':‘和'auto’的用法感到困惑。
浏览 1提问于2016-02-19得票数 23
回答已采纳
6回答
考虑以下代码：
#include <vector>
struct A
{
explicit A(int i_) : i(i_) {}
int i;
};
int main()
{
std::vector<int> ints;
std::vector<A> As(ints.begin(), ints.end());
}
以上内容应该编译吗？我的感觉是它不应该，因为构造函数被标记为explicit。
Microsoft Visual C++表示同意，并给出了明确的错误消息：cannot convert from 'in
浏览 4提问于2010-01-05得票数 8
回答已采纳
我正在学习STL容器，现在我正在探索std::string类。
对于需要迭代器和两个const字符串的insert成员函数，我有点困惑。
下面是我的代码示例：
std::string str = "Hello C++ Dev";
std::string s2 = "C++ Dev";
s2.insert(s2.begin(), str.c_str(), str.c_str() + 5); // ok. or s2.insert(s2.begin(), "Hello There!", "Hello There!" + 5);
cou
浏览 1提问于2019-08-29得票数 1
回答已采纳
来自Java背景，下面的代码让我很困惑。这里混淆的是没有C++关键字的new对象的创建。我正在创建这个对象Student_info info;，然后将它添加到一个向量中。由于我没有使用新关键字创建它，那么它会在堆栈上分配并在循环退出后被销毁吗？如果是这样的话，最后一个循环如何能够正确地从向量中提取信息呢？当添加到向量的所有对象都被销毁时，它不应该抛出异常吗？
struct Student_info {
string name;
vector<double> marks;
};
int main()
{
int num = 2;
vector<
浏览 0提问于2016-03-22得票数 2
回答已采纳
我试图为一个结构编写一个移动构造函数，但是我不明白为什么我不能调用structure成员的move构造函数：
#include <memory>
struct C
{
std::unique_ptr<int[]> mVector;
size_t mSize;
C() = default;
C(C &&temp)
: mVector(temp.mVector)
, mSize(temp.mSize)
{}
};
当我编译它时，我得到：
gcc -c Tem
浏览 3提问于2021-10-03得票数 3
回答已采纳
通过删除"const“，我已经解决了让这段代码编译的问题。然而，为什么在这种特定情况下，我似乎不能在const类方法中分配非类成员呢？这可能是课程的一部分；不过，我不明白为什么。
我有自己的代码要编译，但我对这种情况感到困惑。
下面是类中的一些声明。
using twoDList = multimap<string,string>;
twoDList SomeMultiMap;
当我跳下“康斯特”号时，这个方法就可以了。或者至少是编译。不过，这里我只是分配只在这个函数中声明的迭代器。顺便说一下，使用命名空间std。
bool object::foo(string a, st
浏览 0提问于2019-03-29得票数 0
回答已采纳
2回答
我刚刚遇到了一个棘手的问题，这个问题很容易解决，但我并不喜欢这样做。在我的类的构造函数中，我初始化了数据成员的数据成员。下面是一些代码：
class Button {
private:
// The attributes of the button
SDL_Rect box;
// The part of the button sprite sheet that will be shown
SDL_Rect* clip;
public:
// Initialize the variables
explicit Button(const int
浏览 0提问于2009-09-26得票数 2
回答已采纳
2回答
我正在写一个测试程序来更好地理解vector。在其中一个场景中，我试图将一个值insert到向量的指定位置。代码编译得很干净。然而，在执行时，它从v8.insert(..)行抛出了一个分段错误(参见下面的代码)。我很困惑。有人能告诉我代码中的错误在哪里吗？
#define UNIT_TEST(x) assert(x)
#define ENSURE(x) assert(x)
#include <vector>
typedef std::vector< int > intVector;
typedef std::vector<
浏览 2提问于2010-05-11得票数 2
回答已采纳
4回答
我正在尝试将使用新标准(C++ 0x)编写的函数转换回以前的标准
如何将以下行转换为
typedef std::vector<value3 const*> passmem;
pasmem pm; // neighborhood sequence
std::for_each(pm.begin(), pm.end(), [&] (value3 const* x)
浏览 0提问于2011-07-25得票数 2
2回答
要说的是:以下内容安全吗？
vector<int> v;
int const* last = &*v.end();
// last is never dereferenced
我担心的是，从迭代器中获取一个普通的旧指针的诀窍是强制取消对end()迭代器的引用，这是无效的。即使只是把指针拿回来！
Backgroud：我正在尝试创建一个由任意类型(特别是整数和指向对象的指针)索引的条目集合。
template<class IT>
/// requires IT implements addition (e.g. int, random-access iterato
浏览 2提问于2016-07-17得票数 4
2回答
我的问题是针对这里的C++纯粹主义者。我知道Bjarne Stroustrop希望我们养成使用C++向量的习惯：
对于C样式的数组，您需要：
int arr[] = {69, 2, 3};
初始化C++向量的等效方法是什么？也就是说，当您在C++中编程时，需要一个动态的随机访问容器，并且您已经知道其中需要的一些元素，那么初始化该容器的最佳方法是什么？
显然你可以做到
int myints[] = {16,2,77,29};
std::vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) )
但那不是很优雅.
浏览 0提问于2014-01-03得票数 1
2回答
我对编程很陌生，只举一个例子。
，我已经创建了一个类ptr_generator，它通过构造函数创建一个指针数组。在这里，这些指针指向一个双重向量。然后创建一个ptr_generator类型的向量myvec。。
我在打印指针指向的双数的初始向量时遇到了问题。
有人能帮我弄清楚吗？
/******************************************************************************
Online C++ Compiler.
Code, Compile
浏览 1提问于2021-01-05得票数 0
回答已采纳
这是计算子数组的最大和的函数
int Solution::maxSubArray(const vector<int> &A) {
vector<int>::iterator i;
int max_so_far = *A.begin();
int current_max = *A.begin();
for(i = A.begin(); i != A.end(); ++i)
{
current_max = max(*i,*i+current_max);
max_so_far = max(max_so_far,current_max)
}
浏览 3提问于2016-10-19得票数 2
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
