javascript

java

python

c#

node.js

reactjs

android

php

c++

ruby-on-rails

html

jquery

git

css

ios

sql

.net

c

<img src="//i.stack.imgur.com/bk9VA.png" alt="" class="sponsor-tag-img" width="18" height="16"/>android

string

我在哪里可以获得“有用的”C ++二进制搜索算法?

我需要一个与C ++ STL容器兼容的二进制搜索算法,如标准库的upper_bound标题中的boost::binary_search,但我需要它来返回指向结果的迭代器,而不是一个简单的布尔告诉我是否 元素存在。

(另一方面,当他们为binary_search定义API时,标准委员会在想什么?!)

我主要担心的是我需要二进制搜索的速度,所以尽管我可以用其他算法找到数据,如下所述,我想利用我的数据被排序以获得二进制的好处这一事实 搜索,而不是线性搜索。

到目前为止boost::binary_searchupper_bound如果缺少原点则失败:

//lousy pseudo code
vector(1,2,3,4,6,7,8,9,0) //notice no 5
iter = lower_bound_or_upper_bound(start,end,5)
iter != 5 && iter !=end //not returning end as usual, instead it'll return 4 or 6

注意:只要与容器兼容,我也可以使用不属于std命名空间的算法。 比方说,像boost::binary_search

trans by 2019-08-13T23:13:45Z

c ++ - 如何创建Min stl priority_queue?

默认的stl优先级队列是Max 1(Top函数返回最大的元素)。

为简单起见,它说它是int值的优先级队列。

trans by 2019-08-10T12:47:53Z

stl - 如何在不循环的情况下将数组的内容复制到C ++中的std :: vector?

我有一个值数组,从程序的不同部分传递给我的函数,我需要存储以供以后处理。 由于我不知道在处理数据之前我的函数会被调用多少次,所以我需要一个动态存储结构,因此我选择了std::vector.我不想要这样做 标准循环到push_back单独的所有值,如果我可以使用类似于memcpy的东西复制它将是很好的。

trans by 2019-08-09T13:17:24Z

c ++ - 如何安全地将对象(尤其是STL对象)传入DLL或从DLL传递?

如何将类对象(尤其是STL对象)传递给C ++ DLL?

我的应用程序必须以DLL文件的形式与第三方插件交互,我无法控制这些插件构建的编译器。 我知道STL对象没有保证ABI,我担心我的应用程序会导致不稳定。

trans by 2019-08-05T16:49:11Z

c ++ - gcc std :: unordered_map实现缓慢吗? 如果是这样 - 为什么?

我们正在用C ++开发一个高性能的关键软件。 我们需要一个并发的哈希映射并实现一个。 所以我们写了一个基准来弄清楚,我们的并发哈希映射与std::unordered_map相比要慢多少。

但是,std::map似乎非常慢......所以这是我们的微基准测试(对于并发映射,我们产生了一个新的线程,以确保锁定不会被优化掉,并注意我从来没有inser 0因为我也是基准测试 std::unordered_map,需要空值):

boost::random::mt19937 rng;
boost::random::uniform_int_distribution<> dist(std::numeric_limits<uint64_t>::min(), std::numeric_limits<uint64_t>::max());
std::vector<uint64_t> vec(SIZE);
for (int i = 0; i < SIZE; ++i) {
    uint64_t val = 0;
    while (val == 0) {
        val = dist(rng);
    }
    vec[i] = val;
}
std::unordered_map<int, long double> map;
auto begin = std::chrono::high_resolution_clock::now();
for (int i = 0; i < SIZE; ++i) {
    map[vec[i]] = 0.0;
}
auto end = std::chrono::high_resolution_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
std::cout << "inserts: " << elapsed.count() << std::endl;
std::random_shuffle(vec.begin(), vec.end());
begin = std::chrono::high_resolution_clock::now();
long double val;
for (int i = 0; i < SIZE; ++i) {
    val = map[vec[i]];
}
end = std::chrono::high_resolution_clock::now();
elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
std::cout << "get: " << elapsed.count() << std::endl;

(编辑:整个源代码可以在这里找到:[http://pastebin.com/vPqf7eya)]

std::map的结果是:

inserts: 35126
get    : 2959

对于std::map

inserts: 3653
get    : 816

对于我们手工支持的并发映射(它执行锁定,虽然基准测试是单线程的 - 但是在单独的生成线程中):

inserts: 5213
get    : 2594

如果我在没有pthread支持的情况下编译基准程序并运行主线程中的所有内容,我会得到以下手工支持并发映射的结果:

inserts: 4441
get    : 1180

我用以下命令编译:

g++-4.7 -O3 -DNDEBUG -I/tmp/benchmap/sparsehash-2.0.2/src/ -std=c++11 -pthread main.cc

因此特别是std::map上的插入物似乎非常昂贵 - 其他地图为35秒对3-5秒。 查找时间似乎也很高。

我的问题:这是为什么? 我在stackoverflow上读了另一个问题,有人问,为什么std::map比他自己的实现慢。 有最高评级的答案状态,std::unordered_map需要实现更复杂的接口。 但是我看不出这个论点:我们在concurrent_map中使用了bucket方法,std::map也使用了bucket-approach(google::dense_hash_map没有,但是std::unordered_map应该至少和我们手工支持的并发安全版本一样快?)。 除此之外,我在界面中看不到强制使哈希映射表现不佳的功能的任何内容......

所以我的问题:std::map似乎是非常慢的吗? 如果不是:出了什么问题? 如果是:这是什么原因。

而我的主要问题是:为什么将一个值插入到如此可怕的昂贵中(即使我们在开始时预留了足够的空间,它也没有更好的表现 - 所以重新拍摄似乎不是问题)?

编辑:

首先:是的,所提出的基准并不完美 - 这是因为我们用它玩了很多而且它只是一个黑客(例如生成int的std::map分布在实践中不是一个好主意,在一个中排除0 循环是一种愚蠢的等...)。

目前大多数评论都解释说,我可以通过为它预分配足够的空间来加快unordered_map的速度。 在我们的应用程序中,这是不可能的:我们正在开发一个数据库管理系统,并且需要一个哈希映射来在事务期间存储一些数据(例如锁定信息)。 因此,这个映射可以是从1(用户只进行一次插入和提交)到数十亿条目(如果发生全表扫描)的所有内容。 在这里预先分配足够的空间是不可能的(并且在开始时分配很多将消耗太多内存)。

此外,我很抱歉,我没有说清楚我的问题:我对制作unordered_map并不感兴趣(使用googles密集哈希映射对我们来说很好),我只是不明白这个巨大的性能差异来自何处。 它不能只是预分配(即使有足够的预分配内存,密集映射比unordered_map快一个数量级,我们的手动并发映射以大小为64的数组开始 - 因此比unordered_map小一些)。

那么std::map这种糟糕表现的原因是什么? 或者有不同的问题:是否可以编写std::unordered_map接口的实现,该接口是标准符合和(几乎)与googles密集哈希映射一样快? 或者标准中是否有某些内容强制实施者选择低效的方式来实现它?

编辑2:

通过分析,我看到很多时间用于整数divions。 std::map使用素数作为数组大小,而其他实现使用2的幂。 为什么std::unordered_map使用素数? 如果散列是坏的,要更好地执行? 对于好的哈希,它确实没有任何区别。

编辑3:

这些是std::map的数字:

inserts: 16462
get    : 16978

Sooooooo:为什么插入到std::map比插入std::unordered_map更快...我的意思是WAT? std::map具有更糟糕的局部性(树与阵列),需要进行更多分配(每次插入vs每次重复加上+每次碰撞加1次),最重要的是:具有另一种算法复杂度(O(logn)vs O(1))!

trans by 2019-08-04T20:20:36Z

c ++ - 为什么std :: set没有“包含”成员函数?

我大量使用contains,而且我经常需要检查这样的集合是否包含数字。

我觉得写作很自然:

if (myset.contains(number))
   ...

但由于缺少contains成员,我需要写繁琐的:

if (myset.find(number) != myset.end())
  ..

或者不那么明显:

if (myset.count(element) > 0) 
  ..

这个设计决定有理由吗?

trans by 2019-08-02T10:38:09Z

stl - C ++ map access丢弃限定符(const)

以下代码表示将地图作为const传递到MapWrapper.cpp:10: error: passing ‘const std::map<int, int, std::less<int>, std::allocator<std::pair<const int, int> > >’ as ‘this’ argument of ‘_Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with _Key = int, _Tp = int, _Compare = std::less<int>, _Alloc = std::allocator<std::pair<const int, int> >]’ discards qualifiers方法中会丢弃限定符:

#include <iostream>
#include <map>
#include <string>

using namespace std;

class MapWrapper {
public:
    const int &get_value(const int &key) const {
        return _map[key];
    }

private:
    map<int, int> _map;
};

int main() {
    MapWrapper mw;
    cout << mw.get_value(42) << endl;
    return 0;
}

这是因为地图访问时可能发生的分配吗? 没有地图访问的函数可以声明为const吗?

MapWrapper.cpp:10: error: passing ‘const std::map<int, int, std::less<int>, std::allocator<std::pair<const int, int> > >’ as ‘this’ argument of ‘_Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with _Key = int, _Tp = int, _Compare = std::less<int>, _Alloc = std::allocator<std::pair<const int, int> >]’ discards qualifiers

trans by 2019-08-01T06:00:05Z

c ++ - 如何设置std :: vector的初始大小?

我有一个vector<CustomClass*>,我在矢量中放了很多项目,我需要快速访问,所以我不使用列表。 如何设置向量的初始大小(例如为20 000个位置,以避免在插入新的时复制)?

trans by 2019-07-22T13:41:46Z

c ++ - remove_if等效于std :: map

我试图根据特定情况从地图中删除一系列元素。 我如何使用STL算法?

最初我想过使用remove_if,但由于remove_if不适用于关联容器,因此无法实现。

是否有适用于地图的“remove_if”等效算法?

作为一个简单的选项,我想到循环遍历地图并擦除。 但是循环遍历地图并删除安全选项?(因为迭代器在擦除后变为无效)

我使用以下示例:

bool predicate(const std::pair<int,std::string>& x)
{
    return x.first > 2;
}

int main(void) 
{

    std::map<int, std::string> aMap;

    aMap[2] = "two";
    aMap[3] = "three";
    aMap[4] = "four";
    aMap[5] = "five";
    aMap[6] = "six";

//      does not work, an error
//  std::remove_if(aMap.begin(), aMap.end(), predicate);

    std::map<int, std::string>::iterator iter = aMap.begin();
    std::map<int, std::string>::iterator endIter = aMap.end();

    for(; iter != endIter; ++iter)
    {
            if(Some Condition)
            {
                            // is it safe ?
                aMap.erase(iter++);
            }
    }

    return 0;
}
trans by 2019-07-20T21:58:46Z

stl - 迭代C ++映射中的键

有没有办法迭代键,而不是C ++映射对?

trans by 2019-07-19T20:27:50Z

c ++ - 为什么从函数返回向量是可以的?

请考虑此代码。 我已经多次看过这种类型的代码了。 words是局部向量。 如何从函数中返回它? 我们可以保证它不会死吗?

 std::vector<std::string> read_file(const std::string& path)
 {
    std::ifstream file("E:\\names.txt");

    if (!file.is_open())
    {
        std::cerr << "Unable to open file" << "\n";
        std::exit(-1);
    }

    std::vector<string> words;//this vector will be returned 
    std::string token;

    while (std::getline(file, token, ','))
    {
        words.push_back(token);
    }

    return words;
}
trans by 2019-07-17T22:22:59Z

c ++ - 如何重载std :: swap()

在排序甚至分配期间,许多标准容器(例如std::liststd::vector)使用std::swap()

但是std::swap()的std实现非常普遍,而且对于自定义类型来说效率很低。

因此,通过使用自定义类型特定实现重载std::swap()可以获得效率。 但是如何实现它以便std容器使用它?

trans by 2019-07-17T16:45:41Z

C ++ STL中const_iterator和非const迭代器之间有什么区别?

const_iteratoriterator之间有什么区别?你会在哪里使用其中一个?

trans by 2019-07-08T16:59:57Z

c ++ - 编写自己的STL包含

有没有关于如何编写新容器的指导方针,其行为与任何STL容器一样?

trans by 2019-07-06T06:59:02Z

c ++ - 如何重用ostringstream?

我想清除并重用ostringstream(和底层缓冲区),以便我的应用程序不必进行尽可能多的分配。 如何将对象重置为初始状态?

trans by 2019-07-04T00:34:43Z

c ++ - 解析以逗号分隔的std :: string

这个问题在这里已有答案:

  • 如何迭代字符串的单词?                                     76个答案

如果我有一个包含以逗号分隔的数字列表的std :: string,那么解析数字并将它们放在整数数组中的最简单方法是什么?

我不想将其概括为解析其他任何内容。 只是一个逗号分隔整数的简单字符串,如&#34; 1,1,1,1,2,1,1,1,0&#34;。

trans by 2019-06-29T09:13:59Z

c ++ - 如何根据对的第二个元素对对向量进行排序?

如果我有一对矢量:

std::vector<std::pair<int, int> > vec;

是否有简单的方法根据对的第二个元素按递增顺序对列表进行排序?

我知道我可以编写一个可以完成工作的小函数对象,但有没有办法使用STL的现有部分和std::less直接进行工作?

编辑:我明白我可以编写一个单独的函数或类来传递给第三个参数进行排序。 问题是我是否可以用标准的东西来构建它。 我真的看起来像:

std::sort(vec.begin(), vec.end(), std::something_magic<int, int, std::less>());
trans by 2019-06-26T21:09:01Z

c ++ - const_iterator和iterator有什么区别?

这个问题在这里已有答案:

  • C ++ STL中const_iterator和非const迭代器之间有什么区别?                                     7个答案

这两个关于STL内部实现的区别是什么。性能有什么不同?我想当我们在“只读智能”中遍历矢量时,我们更喜欢const_iterator,对吧?

谢谢。

trans by 2019-06-26T14:03:00Z

c ++ - 为什么我更喜欢使用vector来dequ

以来

  1. 它们都是连续的记忆容器;
  2. 特征明智,deque几乎所有的矢量都有,但更多,因为它在前面插入更有效。

为什么有人会更喜欢std::vectorstd::deque

trans by 2019-06-23T08:19:26Z

stl - C ++将vector <int>转换为vector <double>

什么是将std::vector<int> intVec转换为std::vector<double> doubleVec的良好清洁方式。或者,更一般地说,转换两个可转换类型的向量?

trans by 2019-06-22T04:38:59Z

1 2 3 4 5 下一页 共5页