小编Mar*_*dik的帖子

假设我想使用QTableView和QAbstractTableModel类实现模型/视图架构.所以我继承了QAbstractTableModel创建类MyModel并实现QAbstractTableModel接口.然后QTableView使用该setModel方法将此模型的实例连接到实例.

 #include <QtGui/QApplication>
 #include <QtGui/QTableView>
 #include "mymodel.h"

 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
     QTableView tableView;
     MyModel myModel(0);       
     tableView.setModel( &myModel );
     tableView.show();
     return a.exec();
 }

但是如何才能使模型只读？我无法申报

const MyModel myModel(0);

因为setModel采用非常量参数.我只重新实现了QAbstractTableModel的常量方法.

我在C++项目中使用八度音程库.

#include <octave/oct.h>

刚才我添加了一个标题any_iterator来自Thomas Becker的实现

#include "any_iterator.hpp"

我刚刚添加了标题,无法构建项目.超过20个错误和超过50个警告出现.全部在八度标题中.例如:

/usr/include/octave/lo-mappers.h:52: 
error: expected unqualified-id before ‘(’ token

在代码中:

#if defined (HAVE_CMATH_ISNAN)
inline bool xisnan (double x)
{ return std::isnan (x); }         // line 52
#else

要么

/usr/include/octave/ov-base.h:580: 
error: expected ‘)’ before ‘void’

在声明中:

virtual octave_value isnan (void) const;

一旦我删除标题,问题就消失了.同样在一个单独的项目中,any_iterator工作按预期进行.它只是看起来不能共存.

有任何想法吗？我完全迷失了.该any_iterator连被命名空间的保护.

琐碎的解决方案是:

class Number
{
public: 
    bool isFinite();
    bool isPositive();
    double value();

    ...

private:
    double value_;
    bool isFinite_;
    bool isPositive_;

    ...
};

让我担心的是效率:

从Effective C++:55改进程序和设计的具体方法(第3版)作者:Scott Meyers:

即使小对象具有廉价的拷贝构造器,也可能存在性能问题.有些编译器会以不同的方式处理内置和用户定义的类型,即使它们具有相同的底层表示.例如,一些编译器拒绝将仅由双精度组成的对象放入寄存器中,即使他们乐意定期将裸露的双精度放在那里.当发生这种情况时,你最好通过引用传递这些对象,因为编译器肯定会将指针(引用的实现)放入寄存器中.

有没有办法绕过效率问题？例如,使用某种汇编语言魔法的库？

我正在开发一个性能至关重要的程序.我在那里使用了QMultiMap一个由Qt框架提供的类,类似于std::map.

QMultiMap<int, SomeClass> heavilyUsedMap;

void prepareMap()
{
    ...
    heavilyUsedMap.reserve(nEntries); // There is no reserve.
    // fill heavilyUsedMap with a known number of entries.
}

void useMap()
{
    // computations
    heavilyUsedMap.clear();
}

我经常使用prepareMap().当我想要优化时,分配内存是有意义的heavilyUsedMap.

事实上,容器:QVector<T>,QHash<Key, T>,QSet<T>,QString,并且QByteArray都提供了这种可能性,但QMap<Key, T>并QMultiMap<Key, T>没有.

为什么会这样,我怎么能预分配内存的QMap<Key, T>和QMultiMap<Key, T>？

我正在尝试实现Merge排序算法:

#include <list>
#include <functional>
#include <iterator>
#include <iostream>
#include <random>

template <typename TIterator, typename TObject>
void mergeSort(const TIterator& begin, const TIterator& end,
               std::function<bool (const TObject& left,
                                   const TObject& right)> criterium)
{
    //...
}

bool compare(int a, int b)
{
    return a < b;
}

int main(int argc, char** argv)  // And now to test the algorithm
{
    std::list<int> container;
    for (int i = 0; i < 100; ++i)
        container.push_back(random() % 20);

    mergeSort(container.begin(), container.end(), compare);

    for (auto it = container.begin(); …

我想弄清楚程序分析是如何工作的.我正在使用Valgrind.我的第一个问题是:

Valgrind的功能成本意味着什么？是时候了吗？

从我读到的内容来看,似乎Valgrind在虚拟机上运行该程序,该虚拟机应该反映"通用计算机".然后它计算此机器中发生的事件.但是它如何根据这些数据计算函数的成本呢？可以在标准台式PC上测量小于1毫秒的时间吗？

编辑:

请问callgrind的输出中的1维数"成本"是什么意思？

文件说:

istream::get ( char* s, streamsize n, char delim );

// Extracts characters from the stream and stores them as a 
// c-string into the array beginning at s

我试图分析这个功能的作用.它需要一个"按值"的指针.也就是说它无法分配动态内存并设置指向s它的指针.它只能改变指针s指向的内容.

但是如果函数不能执行动态内存分配,它怎么能返回长度未知的输出呢？我该如何使用这个功能？我应该预先分配内存并将指针传递给它s,然后自己删除吗？

我想声明一个算法,它采用一对迭代器和一个标准.然后它返回满足标准的迭代器范围内的项向量.

template <typename TIterator, typename TCriterium>
std::vector< Type that I will get after dereferencing TIterator >
filter (TIterator begin, TIterator end, TCriterium passes);

我可以使用C++ 11等功能,例如decltype或auto.我试过了:

#include <vector>

template <typename TIterator, typename TCriterium>
auto filter (TIterator begin, TIterator end, TCriterium passes) 
                      -> std::vector< decltype(*begin) >
{
}

int main()
{
    std::vector<int*> vector;
    filter(vector.begin(), vector.end(), 0);
    return 0;
}

但这不起作用.我明白了:

/usr/include/c++/4.7/ext/new_allocator.h:59: 
error: forming pointer to reference type 'int*&'

让我们假设我们有一个:

class Widget;
std::vector<Widget>;

我们有一个功能:

bool belongsToLeft(Widget w);

我想根据这个谓词对容器进行排序.到目前为止,我虽然这个算法.它从范围的两端发展.一旦找到一对同时属于另一端的值,它就会交换它们.

template <typename TIterator, typename TPredicate>
TIterator separate(TIterator begin, TIterator end, TPredicate belongsLeft)
{
    while (true)
    {
        while (begin != end && belongsLeft(*begin))
            ++begin;
        while (begin != end && !belongsLeft(*end))
            --end;
        if (begin == end)
            return begin;
        std::swap(*begin, *end);
    }
}

问题是这个算法不稳定:

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> numbers = {6, 5, 4, 3, 2, 1};
    separate(numbers.begin(), numbers.end(), [](int x){return x%2 == 0;});

    for (int x : numbers)
        std::cout << …

我试图了解内存对齐在C++中是如何工作的.

如果我理解正确,如果n是指针的二进制表示中的尾随零的数量,则指针对齐到2 ^ n个字节.但是,以下程序:

#include <bitset>
#include <cstdint>
#include <iostream>
#include <climits>
#include <cassert>

template <typename T>
std::size_t nTrailingZeros(const T* pointer)
{
    assert(CHAR_BIT == 8);
    std::bitset<8*sizeof(std::uintptr_t)> bits(reinterpret_cast<std::uintptr_t>(pointer));
    std::size_t nZeroes{};
    while (nZeroes < bits.size() && !bits[nZeroes])
    {
        ++nZeroes;
    }
    return nZeroes;
}

struct alignas(64) A {int x;};

int main()
{
    std::cout << "Alignment: "      << alignof (A)            << std::endl;
    std::cout << "Trailing zeros: " << nTrailingZeros (new A) << std::endl;
} 

输出:

对齐:64尾随零:4

在我的电脑上.

我究竟做错了什么？我期望至少6个尾随零,但我只得到4(建议16字节对齐).