相关疑难解决方法(0)

我想将矩阵的每一行写入二进制文件.我尝试这样写:

vector< vector<uint32_t> > matrix;

...

for(size_t i = 0; i < matrix.size(); ++i)
ofile->write( reinterpret_cast<char*>(&matrix[i]), sizeof(uint32_t*sizeof(matrix[i])) );
{
    for(size_t j = 0; j < numcols; ++j)
    {
        std::cout << left << setw(10) << matrix[i][j];
    }
    cout << endl;
}

但它不起作用,我得到垃圾数字.

任何帮助,赞赏,

特德.

我一直在使用相同的std::vector<int>,以便尽量避免分配deallocating.在几行中,我的代码如下:

std::vector<int> myVector;
myVector.reserve(4);

for (int i = 0; i < 100; ++i) {
    fillVector(myVector);
    //use of myVector
    //....
    myVector.resize(0);
}

在每次迭代中,myVector最多将填充4个元素.为了制作高效的代码,我想永远使用myVector.但是,在被摧毁myVector.resize()的元素中myVector.我明白这myVector.clear()会产生同样的效果.

我想如果我可以覆盖现有的元素,myVector我可以节省一些时间.但是我认为std::vector不能做到这一点.

有没有办法做到这一点？创建一个覆盖元素的本土实现是否有意义？

我有这两个简单的功能.我认为这func1是一个很好的解决方案,因为你通过引用传递一个对象.我的教科书给出func2了最佳解决方案的答案.这只是因为你没有解除分配heapstr吗？如果我heapstr在main中声明然后将它传递给函数,那么我之后能够将其删除怎么办？

#include <iostream>

using namespace std;


string& func1(const string &str) {
    string* heapstr=new string();
    for (int i = 0; i < str.size(); ++i) {
        *heapstr += str[i];
    }
    return *heapstr;
}

string func2(const string &str) {
    string heapstr;
    for (int i = 0; i < str.size(); ++i) {
        heapstr += str[i];
    }
    return heapstr;
}

int main() {
    cout << func1("aaa") << endl;
    cout << func2("aaa") << endl;
}

这个问题可能是重复的.我一直在网上寻找这个想法,但我找不到任何东西.'new'和'*new'有什么区别？:

int main()
{
    class Cat
    {
        //Code
    }

    new Cat();
    *new Cat();

    return 0;
}

以下 C++ 代码的时间复杂度是多少：（注意我使用的是 gcc，所以 len 作为用户的输入）

int array[len]; \\array is uninitialized

是 O(1) 还是 O(len) ？我有点困惑。

它可能不清楚,但是,当我阅读msdn doc并尝试深入理解Struct行为时.

来自msdn

处理堆栈:

这将带来性能提升.

并且:

每当您需要经常使用的类型并且大部分只是一个数据时,结构可能是一个不错的选择.

我不明白因为,我想当我传递一个方法的参数时,"复制值"过程必须比"复制参考"过程慢？

我有一个简单的问题,是否只使用指针而不是正常变量,无论是时间上还是内存上都会提高程序的效率？对于一个实例,如果我使用以下程序来交换两个整数.

#include<iostream>
#include<conio.h>
#include<new>
using namespace std;
int main()
{
   int *a=new int;
   int *b=new int;
   int *c=new int;
   cin>>(*a)>>(*b);
   *c=*a;*a=*b;*b=*c;
   cout<<"swapping";
   cout<<*a<<*b;
getch();
}

我知道从堆栈中分配内存更快,但是当访问更快的变量时:

void fn1()
{
    int *p=new int[50];
    for(int i=0;i<50;i++)
        p+i=i*i;
}

void fn2()
{
    int p[50];
    for(int i=0;i<50;i++)
        p[i]=i*i;
}

上述哪些功能会更快执行？

我问它是因为我正在用c ++创建一个游戏引擎,并且我经常进行绘制调用,这些调用很小,只涉及矩阵的转换,旋转等,因此哪个分配对我的目的最有用