相关疑难解决方法(0)

以下代码:

string a = "abc";
cout << a.capacity();
a.erase(a.begin() + 1, a.end());
cout << a.capacity();

...输出:

33

即使我从字符串中删除了一些元素,容量也保持不变.所以我的问题是:

1. 由于容量,一些内存是否被阻止？如果我没有明确表示reserve()怎么办？

2. 如果我使用reserve()并且最终没有使用整个容量,我是否在浪费内存？

3. 如果需要,这个额外的内存(我没有使用)会被分配给其他东西吗？

编辑:假设我有

 string a= "something";
 a = "ab";

现在我知道a不会超过两个字符.所以打电话reserve(2)让记忆不浪费是明智的吗？

在 C 中，有一个很好的构造来创建具有更多分配空间的 C 字符串：

char str[6] = "Hi";  // [H,i,0,0,0,0]

我以为我可以使用 (4) 版本的字符串构造函数做同样的事情，但参考文献说

如果 s 未指向 CharT 的至少 count 个元素的数组，则行为未定义。

所以使用起来并不安全

std::string("Hi", 6);

有没有办法创建这样的 std::string 而不需要额外的副本和重新分配？

通常,我会std::string从函数返回a ,因为返回a const char*将要求调用者提供输出内存缓冲区,并且该缓冲区不可调整大小.

但是const char*从字符串文字返回一个有效的if？

const char* generate_c_string() {
    return "ABC";
}

这样做(如果有效)可能会更快,因为我不需要动态分配内存来构造一个std::string.

它可能是有效的,因为它const char* x = "ABC";是有效的.是否有来自C++标准的参考资料证实其有效性？

下面的代码以free(): double free detected in tcache 2. 我想知道错误发生的内部过程。

#include <string>

class test
{
private:
    std::string member;
public:
    test(const std::string & arg) { member = arg; };
};

int main()
{
    test T = test("test test test test");
    T.~test();
    return 0;
}

错误取决于给定字符串的长度；如果您更改"test test test test"为"test"，则程序运行良好，至少g++在我的计算机上是这样。

const 向量无法修改，因为它是 const 对象。所以插入、追加、删除都是不允许的。然而，它的内容不是该对象的一部分，而是由该对象拥有。举个类似的例子：

int* const p = new int[10]{1,2,3,4};

p是一个 const 对象，拥有可以修改的非常量数据：p[1]=5;

Vector 的operator[]条件是向量是否为 const，如果是，则返回 aconst int&但如果基础值不是 const，则删除 const 的 const 强制转换应该是合法的。

为了测试这一点，我编写了以下程序：

#include <vector>

constexpr int foo()
{
    const std::vector<int> v{ 1,2,3 };
    const int a[3]{ 1,2,3 };
    *const_cast<int*>(&v[1]) = 21;

    // However, this should fail and does on GCC and CLANG
    //*const_cast<int*>(&a[1]) = 21;
    return v[1];
}

int main()
{
    constexpr int sb21 = foo();
    const std::vector<int> v{ 1,2,3 };
    *const_cast<int*>(&v[1]) …

什么方法应该更快？第一种方法是增加一个变量以减少：

#pragma omp parallel private(seed, x, y, i) reduction (+:counter)
{
    seed = 25234 + 17 * omp_get_thread_num();
    nproc = omp_get_thread_num();
    #pragma omp parallel for
    for(i=0; i<prec/8; i++){
        x = (double)rand_r(&seed) / RAND_MAX;
                y = (double)rand_r(&seed) / RAND_MAX;
        if(x*x+y*y<1){
            counter++;
        } 

}

第二个是使用每个进程的增量变量表，最后，该表中元素的总和是一个结果：

#pragma omp parallel private(seed, x, y, i , nproc)
{
    seed = 25234 + 17 * omp_get_thread_num();
    nproc = omp_get_thread_num();
    #pragma omp parallel for
    for(i=0; i<prec/8; i++){
        x = (double)rand_r(&seed) / RAND_MAX;
        y = (double)rand_r(&seed) / RAND_MAX; …

我有一个相对较大的文件,我需要确保只包含唯一的行.该文件只有500MB.我知道有很多开销,但我看到了近5GB的RAM使用率.我可以使用外部合并排序并保持少量RAM,但这似乎更快编码.

我正在使用VC++ 14.

#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <unordered_set>

using std::vector;
using std::string;
using std::unordered_set;

class uniqify {
    unordered_set<string> s;
public:
    auto exists(const string &filename) const -> bool {
        std::ifstream fin(filename);
        bool good = fin.good();
        return fin.close(), good;
    }

    void read(const string &filename) {
        std::ifstream input(filename);
        string line;
        while (std::getline(input, line))
            if (line.size())
                s.insert(line);
    }

    void write(const string &filename) const {
        std::ofstream fout(filename);
        for (auto line : s)
            fout << line << "\n";
        fout.close(); …

通过非常糟糕的设计,是否有可能在没有堆分配的情况下在C++中创建内存泄漏？

我想到的一个例子,请纠正我,如果它不符合我的想法:

#include <iostream>
#include <string>

void WhatIsYourName()
{
  std::string name;
  std::cout << "What is your name? ";
  getline (std::cin, name);
  std::cout << "Hello, " << name << "!\n";

  WhatIsYourName();
}

int main()
{
  WhatIsYourName();
}

对我来说,它似乎WhatIsYourName()是std::string name在每次调用时初始化一个新的,但该函数永远不会超出范围,因此内存永远不会被释放.是对的吗 ？或者编译器是否足够智能以确定将来不会使用该变量,因此如果函数超出范围,它会删除它？

什么样的其他糟糕的设计只使用堆栈分配会造成内存泄漏？

如何创建将const char*直接用作键的map/unordered_map ？

如果我使用map<std::string,..>,那么在每个解析时都会创建map["abc"] = ...一个新std::string对象.这会导致分配内存,创建字符串对象并将字符串复制到其中的大量开销.

如何声明const char*直接使用而没有任何开销的地图对象？

正如我们所知,当一个可移动的物体被分配给另一个相同类型的物体时,它将不会被深深地复制.通过这种方式,我们可以节省大量时间.但是今天,我发现了一种现象.请查看以下代码.

#include <string>
#include <iostream>
int main() {
std::string s1 = "s1";
std::string s2 = "s2";

std::cout << "  s1[" << ( void* ) &s1[0] << "]:" + s1
    << ", s2[" << ( void* ) &s2[0] << "]:" + s2
    << std::endl;
s1.swap( s2 );
std::cout << "  s1[" << ( void* ) &s1[0] << "]:" + s1
    << ", s2[" << ( void* ) &s2[0] << "]:" + s2
    << std::endl;

s2 = std::move(s1);
std::cout << "  s1[" …