我想要一个std :: vector来包含一些函数,并且可以实时添加更多函数.所有函数都有这样的原型:
void name(SDL_Event*event);
我知道如何创建一个函数数组,但是如何创建一个std :: vector函数？我试过这个:
std::vector<( *)( SDL_Event *)> functions;
std::vector<( *f)( SDL_Event *)> functions;
std::vector<void> functions;
std::vector<void*> functions;
但它们都没有奏效.请帮忙
我想知道在C中是否有替代std :: vector？我发现了这个实现,但似乎包含内存重新分配的一些问题.
我想使用std::arrayC++ 11作为我自己班级的一个领域.它需要两个模板参数(第一个定义数据类型,第二个定义数组的大小).
但我只知道构造函数中的第二个参数.我不熟悉C++ 11标准,但我认为在执行期间不可能设置模板参数.
还有其他选择std::array吗？std::vector可能有点太多了,因为我永远不会改变它的大小.
在C++中,我希望分配一个固定大小(但在运行时确定的大小)std :: vector然后写入此向量中的元素.这是我正在使用的代码:
int b = 30;
const std::vector<int> test(b);
int &a = test[3];
但是,这给了我一个编译器(MSVC 2010 Pro)错误:
错误C2440:'initializing':无法从'const int'转换为'int&'.转换失去限定符.
我对const的理解是它使一个类的所有成员变量保持不变.例如,以下工作正常:
class myvec
{
public:
myvec(int num) : ptr_m(new int[num]) {};
~myvec() { delete ptr_m; }
void resize(int num) { delete ptr_m; ptr_m = new int[num]; }
int & operator[] (int i) const { return ptr_m[i]; }
int *ptr_m;
};
const myvec test(30);
int &a = test[3]; // This is fine, as desired
test.resize(10); // Error here, as expected
因此,似乎std :: …
我使用外部库来处理大量数据.数据由原始指针传入,加上长度.该库不声明指针的所有权,但在完成数据时调用提供的回调函数(具有相同的两个参数).
通过使用方便地准备数据std::vector<T>,我宁愿不放弃这种便利.复制数据是完全不可能的.因此,我需要一种方法来"接管"一个拥有的内存缓冲区std::vector<T>,并且(稍后)在回调中释放它.
我目前的解决方案如下:
std::vector<T> input = prepare_input();
T * data = input.data();
size_t size = input.size();
// move the vector to "raw" storage, to prevent deallocation
alignas(std::vector<T>) char temp[sizeof(std::vector<T>)];
new (temp) std::vector<T>(std::move(input));
// invoke the library
lib::startProcesing(data, size);
并且,在回调函数中:
void callback(T * data, size_t size) {
std::allocator<T>().deallocate(data, size);
}
这个解决方案有效,因为标准分配器的deallocate函数忽略了它的第二个参数(元素计数)并且只是调用::operator delete(data).如果没有,可能会发生坏事,因为size输入向量可能比它小得多capacity.
我的问题是:是否有一种可靠的(以及C++标准)接管缓冲区std::vector并在以后"手动"释放它的方式？
我有一个std::vector在我称之为reserve一个较大的值.然后我检索data().
由于迭代data然后崩溃,我想知道这是否是允许的.被reserve强制更新data已分配内存的范围是多少？
使用gcc 4.9,使用Linaro工具链对ARM进行交叉编译,我vector.assign()在添加时发现了更改的编译结果-std=c++14,其方式会产生严重的性能问题.
我已经尝试了几种不同的方式来执行此分配+复制,但只要我习惯这样做,所有这些方法都会std::vector遇到此性能问题.
我可以通过这个玩具示例重现问题:
VectorTest.h
#include <stdint.h>
#include <stddef.h>
#include <vector>
struct VectorWrapper_t
{
VectorWrapper_t(uint8_t const* pData, size_t length);
std::vector<uint8_t> data;
};
VectorTest.cpp
#include "VectorTest.h"
VectorWrapper_t::VectorWrapper_t(uint8_t const* pData, size_t length)
{
data.assign(pData, pData + length);
}
gcc标志:
-std=c++14 \
-mthumb -march=armv7-a -mtune=cortex-a9 \
-mlittle-endian -mfloat-abi=hard -mfpu=neon -Wa,-mimplicit-it=thumb \
-O2 -g
查看程序集,我可以看到原因:原始版本(C++ 03,我假设？)调用memmove,而C++ 14版本则添加了一个额外的循环,它看起来像是手动复制数据.看看.locgcc添加的标签-fverbose-asm,这个循环中的指令来自stl_construct.h和stl_uninitialized.h.
更改为gcc 5.2.1(使用C++ 14),它的编译几乎与C++ 03示例完全相同,除了memcpy代替memmove.
我可以通过使用std::unique_ptr<uint8_t[]>而不是在 …
当我创建一个std :: vector对象时,并不总是调用这些对象的构造函数.
#include <iostream>
#include <vector>
using namespace std;
struct C {
int id;
static int n;
C() { id = n++; } // not called
// C() { id = 3; } // ok, called
};
int C::n = 0;
int main()
{
vector<C> vc;
vc.resize(10);
cout << "C::n = " << C::n << endl;
for(int i = 0; i < vc.size(); ++i)
cout << i << ": " << vc[i].id << endl;
}
这是我得到的输出:
C::n = 1 …我已经将文件内容读入char数组,然后将其中的一些数据读入向量中.如何将一系列char数组复制到向量中？vector和char数组都是相同的类型(unsigned char).
目前的代码是这样的:
int p = 0;
for(...){
short len = (arr[p+1] << 8) | arr[p+0];
p+=2;
...
for(...len...){
vec.push_back(arr[p]);
p++;
}
}
我想通过放弃循环来改进这个push_back,怎么样？
我正在尝试为我的软件定义一个好的设计,这意味着要小心对某些变量的读/写访问.在这里,我简化了讨论的程序.希望这对其他人也有帮助.:-)
假设我们有一个类X如下:
class X {
int x;
public:
X(int y) : x(y) { }
void print() const { std::cout << "X::" << x << std::endl; }
void foo() { ++x; }
};
我们还要说,将来这个类将被子类化为X1,X2,......这可以重新实现print()和foo().(virtual为了简单起见,我省略了所需的关键字,因为它不是我面临的实际问题.)
既然我们将使用polymorphisme,那么让我们使用(智能)指针并定义一个简单的工厂:
using XPtr = std::shared_ptr<X>;
using ConstXPtr = std::shared_ptr<X const>;
XPtr createX(int x) { return std::make_shared<X>(x); }
到目前为止,一切都很好:我可以定义goo(p)哪些可以读写p,hoo(p)哪些只能读取p.
void goo(XPtr p) {
p->print();
p->foo();
p->print();
}
void hoo(ConstXPtr p) {
p->print();
// p->foo(); …