小编Mar*_*dik的帖子

我试图了解如何迭代实现的哈希表.我无法想象它.我对这种迭代的速度特别感兴趣.例如:

QHash<int, std::string> hashTable;
...
for (auto it = hashTable.begin(); it != hashTable.end(); ++it)
    std::cout << it.value() << std::endl;

这是一个O(hashTable.size())手术吗？

我试图挖掘源代码,但找不到合适的定义.

假设我想根据一些标准删除项目.让我们说:

QMap<int, int> map;

我想删除所有值为奇数的项目.如果我使用迭代器:

for (auto it = map.begin(); it != map.end(); ++it)
    if (it.value() % 2 == 1)
        map.remove(it.key());

这个代码可能是错的,因为调用了

map.remove(it.key()) 

使迭代器无效.如何在每次删除后不重置迭代器的情况下执行此操作？

我试图在QtCreator的Locals and Expressions窗口中看到Eigen向量的内容:

我看到它是一个包含10个组件的向量:

但当我点击它打开时,我得到:

我试着用这个脚本来做这个伎俩.我将它与一个空的__init__.py文件一起保存到〜/ Scripts/Eigen文件夹中并创建了.gdbinit文件:

python
import sys
sys.path.insert(0, '/home/martin/Scripts/Eigen')
from printers import register_eigen_printers
register_eigen_printers (None)
end

我重新启动了QtCreator,没有任何改变.我在QtCreator设置中检查了"在启动时读取.gdbinit"选项,但仍然没有.

令我担心的是,我知道在过去看到Eigen对象的工作没有我干涉一些脚本.

拜托,我做错了什么？

我在用:

gcc版本4.8.1
Ubuntu 13.10
gdb 7.6.1-ubuntu
Qt Creator 3.0.0
基于Qt 5.2.0

我正在编译使用这些标志:

g++ -c -pipe -gdwarf-4 -fvar-tracking-assignments -g 
    -Wall -W -fPIE -DQT_QML_DEBUG -DQT_DECLARATIVE_DEBUG

编辑:

正如@ggael建议的那样,我试图直接运行gdb:

(gdb) run
Starting program: /home/martin/Projects/TestGrounds/test 
Traceback (most recent call …

当一个类有一个默认的构造函数时,我可以使用与指向函数std::make_shared的指针相同的方式实例化.这可能是因为实例化的模板必须编译并存储在内存中,并且其地址必须存在.

#include <memory>
#include <functional>

class DefaultConstructible
{
};

typedef std::function<std::shared_ptr<DefaultConstructible>()> Generator;

int main()
{
    Generator generator(std::make_shared<DefaultConstructible>);
    std::shared_ptr<DefaultConstructible> defConst = generator();

    return 0;
}

但是当我添加一个非平凡的构造函数时,同样的事情失败了:

#include <memory>
#include <functional>

class FromInt
{
public:
    FromInt(int a):a_(a){}
    int a_;
};

typedef std::function<std::shared_ptr<FromInt>(int)> Generator;

int main()
{
    Generator generator(std::make_shared<FromInt>);
    std::shared_ptr<FromInt> p = generator(2);

    return 0;
}

我收到编译器错误:

 error: no matching function for call to 
'std::function<std::shared_ptr<FromInt>(int)>::function(<unresolved overloaded function type>)'
     Generator g(std::make_shared<FromInt>);
                                          ^

为什么会这样,我怎样才能编译代码？

如果我们天真地计算平均值:

std::vector<double> values;
double sum = std::accumulate(begin(values), end(values), 0.0);
double mean = sum / values.size();

并且values.size()很大,我们可能会得到不准确的结果,因为浮点数在较高范围内的分辨率较低.或者更糟糕的是,如果我理解正确,我们可以获得无限的结果.

当我们有偶数个值时,我们可以计算前半部分的平均值,然后计算第二个的平均值,并找到这两个均值的平均值.

这似乎不是一个新问题,但我很难找到资源.我觉得有更复杂的技术与权衡中

• 稳健性
• 计算复杂性
• 难以实施

我想知道是否有人将它们总结到某个地方甚至更好,如果它们在某些图书馆中可用的话.

我正在阅读" 计算复杂性:现代方法"这本书,我在理解不经意的图灵机时遇到了问题.

不经意的图灵机(TM)是这样的TM,其头部的移动完全由输入的长度决定.也就是说,TM没有注意到它的输入.到现在为止还挺好.

但其中一个练习是证明以下定理:

If a language L is decidable in time T(n) 
then there exists an oblivious TM that decides L in time O(T(n)^2). 

很明显,不可思议的TM不能在原始输入上操作,L而是在某些编码版本上操作.即,定理的主旨是编码一个的比特串到整数(在不经意TM的输入的长度).但是如果想要将L(位串)的可能输入集合编码为整数,则由于存在2^n长度的位串,因此会很快地遇到非常高的数字n.

我能正确理解问题吗？你如何证明这个定理？

我注意到QMap::operator[](const Key & key)有这两个重载:

    T & QMap::operator[](const Key & key)
const T QMap::operator[](const Key & key) const

是否有理由按价值返回？

因为我们有移动语义:

当按值返回时,我们应该返回const值吗？

我问的原因是这样的:

想象一下,我们有:

class ExpensiveToCopy;
{
public:
    int someProperty() const;
    ...
}

void f(const QMap<int, ExpensiveToCopy>& map)
{
    int lala = map[4].someProperty(); // We need to copy the entire object
                                      // just to look at someProperty();
}

我通过阅读新的C++ FAQ,我看到,即使x == y对于double x, y;那么有可能为:

std::cos(x) == std::cos(y)

评估false.这是因为机器可以具有支持扩展精度的处理器,使得一部分==是64位数而另一部分是80位数.

但是,下一个示例似乎不正确:

void foo(double x, double y)
{
  double cos_x = cos(x);
  double cos_y = cos(y);
  // the behavior might depend on what's in here
  if (cos_x != cos_y) {
    std::cout << "Huh?!?\n";  // You might end up here when x == y!!
  }
}

据我在en.cppreference.com上所读:

转换和赋值剥离了任何无关的范围和精度:这模拟了将扩展精度FPU寄存器中的值存储到标准大小的存储器位置的操作.

因此,分配:

double cos_x = cos(x);
double cos_y = cos(y);

应该削减任何额外的精度,使程序完全可预测. …

我做了一个简单的Dockerfile：

FROM openjdk
EXPOSE 8080

并使用以下方法构建图像：

docker build -t test .

我安装并配置了一个 docker GitLab CI runner，现在我想在我的test图像中使用这个 runner 。所以我写了以下.gitlab-ci.yml文件：

image: test

run:
  script:
    - echo "Hello world!"

但令我失望的test是，没有找到我可以在我的机器上使用的本地图像。

Running with gitlab-ci-multi-runner 9.4.2 (6d06f2e)
  on martin-docker-rawip (70747a61)
Using Docker executor with image test ...
Using docker image sha256:fa91c6ea64ce4b9b44672c6e56eed8312d0ec2afc80730cbee7754bc448ea22b for predefined container...
Pulling docker image test ...
ERROR: Job failed: Error response from daemon: repository test not found: does not exist or no pull access …

此代码无法编译:

#include <QString>

/* relevant part:
struct QString 
{
  ~QString() noexcept(false) {};
};
*/

class Base
{
public:
    virtual ~Base() = default;
};

class Derived : public Base
{
    QString string_;
};

int main()
{
    return 0;
}

错误是:

error: looser throw specifier for 'virtual Derived::~Derived()'
error:   overriding 'virtual Base::~Base() noexcept (true)'

我没有使用异常的经验,但我认为问题是QString析构函数没有异常说明符,因此隐式创建的Derived::~Derived也没有异常说明符.这是隐含的不兼容Base::~Base是noexcept(true).

如果我QString用类noexcept(true)(例如std::string)排除或替换它,代码将编译.

起初我认为我可以通过将两个析构函数声明为noexcept(false):

virtual ~Base() noexcept(false) = default;
virtual ~Derived() noexcept(false) = …