标签: std

有std::pair引用是否有效？特别是,赋值运算符是否存在问题？根据这个链接,似乎没有对operator =进行特殊处理,因此无法生成默认的assignement运算符.

我希望有一个pair<T&, U&>并且能够为其分配另一对(值或引用)并修改指向的对象.

 char * val;                                                                        
 val = getenv("ENV_VAR_NAME");

上面是获取环境变量的代码,如果我不释放getenv(char*)返回的内存,它会导致内存泄漏吗？如果没有那么请回答原因？

我想知道是否只应用一些标准算法就可以编写一个比较两个的短函数,std::map<string, string>如果所有键值(但是有些)都为真,则返回true.

例如,这两个地图应该被评估为相等

map<string,string> m1, m2;

m1["A"]="1";
m2["A"]="1";

m1["B"]="2";
m2["B"]="2";

m1["X"]="30";
m2["X"]="340";

m1["Y"]="53";
m2["Y"]="0";

假设两个映射具有相同的大小,并且除了由键"X"和键"Y"存储的值之外,它们的所有元素必须成对比较.第一次尝试将是一个非常低效的双嵌套for循环.我相信可以实现更好的解决方案.

我比较两个 std::set

#include <cstdlib>
#include <cstdio>
using namespace std;

#include <vector>
#include <set>


int main(int argc, char** argv)
{
    int myints1[]= {10,20,30,40,50};
    int myints2[]= {50,40,30,20,10};
    std::set<int> s1 (myints1,myints1+5);
    std::set<int> s2(myints2,myints2+5);
    if(s1==s2){
        printf("sets: true");
    }else printf("sets: false");
    std::set<int>::iterator it2=s2.begin();
    for(std::set<int>::iterator it1=s1.begin();it1!=s1.end();it1++){
                printf("\ns1: %d  s2: %d",*it1,*it2);
        it2++;
    }
}

输出:

sets: true
s1: 10  s2: 10
s1: 20  s2: 20
s1: 30  s2: 30
s1: 40  s2: 40
s1: 50  s2: 50

题:

这是正确的方法吗？或者是比较两组的任何其他(特殊)方式？

使用具有两个字段和一对的结构之间的内存分配和效率有什么区别？

我想初始化一个std::map.现在我正在使用,::insert但我觉得我浪费了一些计算时间,因为我已经知道我想要分配的大小.有没有办法分配固定大小的地图,然后填写地图？

为什么 numeric_limits :: min返回int的负值,但是例如float和double的正值？

#include<iostream>
#include<limits>

using namespace std;

int main() {
  cout << "int: " << numeric_limits<int>::min() << " "
       << "float: " << numeric_limits<float>::min() << " "
       << "double: " << numeric_limits<double>::min() << "\n";
  return 0;
}

输出:

int: -2147483648 float: 1.17549e-38 double: 2.22507e-308

从cppreference:

返回数值类型T表示的最小有限值.

对于具有非规范化的浮点类型,min返回最小正标准化值.请注意,此行为可能是意外的,尤其是与整数类型的min行为进行比较时.要查找没有小于它的值的值,请使用 numeric_limits::lowest.

min仅对有界类型和无界无符号类型有意义,也就是说,表示无限负值集的类型没有有意义的最小值.

在C++11我们可以将对象的所有权转移到另一个unique_ptr使用std::move().所有权转移后,放弃所有权的智能指针变为null并get()返回nullptr.

std::unique_ptr<int> p1(new int(42));
std::unique_ptr<int> p2 = std::move(p1); // Transfer ownership

在将所有权转让给另一个所有权的情况下,这有什么用unique_ptr？

C++标准似乎让有关能力的副作用通过或者没有声明 resize(n),与n < size(),或clear().

它确实作出了关于摊销成本push_back和pop_back- O(1)的声明

我可以设想一种实现通常的容量变化和CLRS算法(例如,放大时加倍,减少时减半size to < capacity()/4).(Cormen Lieserson Rivest Stein)

有没有人参考任何实施限制？

我试图解决C ++中的编码问题，该问题计算素数的数量小于非负数的数量n。

所以我首先想出了一些代码：

int countPrimes(int n) {
    vector<bool> flag(n+1,1);
    for(int i =2;i<n;i++)
    {
        if(flag[i]==1)
            for(long j=i;i*j<n;j++)
                flag[i*j]=0;
    }
    int result=0;
    for(int i =2;i<n;i++)
        result+=flag[i];
    return result;
}

这需要88毫秒，并使用8.6 MB的内存。然后，我将代码更改为：

int countPrimes(int n) {
    // vector<bool> flag(n+1,1);
    bool flag[n+1] ;
    fill(flag,flag+n+1,true);
    for(int i =2;i<n;i++)
    {
        if(flag[i]==1)
            for(long j=i;i*j<n;j++)
                flag[i*j]=0;
    }
    int result=0;
    for(int i =2;i<n;i++)
        result+=flag[i];
    return result;
}

这需要28毫秒和9.9 MB。我真的不明白为什么在运行时间和内存消耗上都存在这样的性能差距。我已阅读相类似的问题这一个和那一个，但我仍然困惑。

编辑：我的运行时间与11.5 MB的存储器替换之后减少至40毫秒vector<bool>与vector<char>。