标签: c++

如何在C++ 11中解释下面的成员函数原型？

class C {
 public:
  auto f(...) -> T const;
}

在我看来,它既可以是类C的const成员函数,也可以是非const成员函数,它返回类型为T的const值.

我知道我可以把函数写成

T const f(...);

要么

T f(...) const;

但是,我希望与我声明函数的方式保持一致,因此我决定在auto f(...) -> RetType任何地方使用新的C++ 11 方法.

我必须缺少一个带头文件的基本概念,因为当我尝试从单独的源文件调用最简单的函数时,我得到一个错误:

main.obj:-1:错误:LNK2019:函数_main中引用的未解析的外部符号"void __cdecl buildDeck(int,int)"(？buildDeck @@ YAXHH @ Z)

加入deck.h

#ifndef DECK_H
#define DECK_H
#include <QString>


void buildDeck(int deckSize, int jokers);


struct card
{
    QString suit;
    QString color;
    int rank;
};

#endif // DECK_H

deck.cpp

#include"mainwindow.h"
#include "deck.h"

void buildDeck(int deckSize, int jokers)
{
    int blackRed = deckSize-=jokers;
}

main.cpp中

#include "mainwindow.h"
#include "deck.h"
#include <QApplication>
#include <QPushButton>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    buildDeck(10,20);

    return a.exec();
}

这给了我一个错误.但是,如果我将函数定义从deck.cpp移动到main.cpp的底部,那么应用程序将构建.

所有文件都包含在同一个项目中,并存储在同一目录中.

其他文件:

.pro文件

QT       += core …

"自恋数字"是n位数字,其数字的所有n次方的总和等于数字.

所以,这153是一个自恋的数字,因为1^3 + 5^3 + 3^3 = 153.

现在给定N,找到N个数字长度的所有自恋数字？

我的方法:迭代所有数字做数字的幂和

并检查是否有相同的数字,我计算了权力.

但这还不够好,有没有更快的方法？!

更新: 在自然界中只有88个自恋数字,最大的是39位数字,但我只需要长度为12或更短的数字.

我的代码:

long long int powers[11][12];
// powers[x][y] is x^y. and its already calculated

bool isNarcissistic(long long int x,int n){
    long long int r = x;
    long long int sum = 0;

    for(int i=0; i<n ; ++i){
        sum += powers[x%10][n];
        if(sum > r)
            return false;
        x /= 10;
    }
    return (sum == r);
}

void find(int n,vector<long long int> &vv){
    long long …

假设对齐的指针加载和存储在目标平台上自然是原子的,这有什么区别:

// Case 1: Dumb pointer, manual fence
int* ptr;
// ...
std::atomic_thread_fence(std::memory_order_release);
ptr = new int(-4);

这个:

// Case 2: atomic var, automatic fence
std::atomic<int*> ptr;
// ...
ptr.store(new int(-4), std::memory_order_release);

还有这个:

// Case 3: atomic var, manual fence
std::atomic<int*> ptr;
// ...
std::atomic_thread_fence(std::memory_order_release);
ptr.store(new int(-4), std::memory_order_relaxed);

我的印象是它们都是等价的,但是Relacy在第一种情况下(仅)检测到数据竞争:

struct test_relacy_behaviour : public rl::test_suite<test_relacy_behaviour, 2>
{
    rl::var<std::string*> ptr;
    rl::var<int> data;

    void before()
    {
        ptr($) = nullptr;
        rl::atomic_thread_fence(rl::memory_order_seq_cst);
    }

    void thread(unsigned int id)
    {
        if (id == 0) { …

C++标准说明了关于等于运算符的以下内容==:

[C++11: 5.10/1]: [..]相同类型的两个指针比较相等,当且仅当它们都为空时,都指向相同的函数,或者两者都表示相同的地址.

我的初步解释是函数本身在语义上没有"地址"本身,因此"或两者代表相同的地址"只能用于引用对象,而不是函数.否则为什么要打扰"指向同一个功能"条款呢？

也就是说,当且仅当两者都指向相同的函数period时,相同类型的两个函数指针才相等.

这样做的结果是在这个问题中看到的行为(指向两个不同但相同的函数的指针具有相同的值)将是一个实现错误,因为指向不同函数的指针将是唯一的.

我觉得,这是该条款的意图,但我不能找到一种方法来客观地捍卫的观点,这是何等的通道的意思实际上应该推断,或者它真的是委员会的意图,现在我的解释已经成为问题:

[D]跟我说"[...]或两者代表同一个地址." 不满足于Visual C++的行为.(@jstine)

所以我的问题是关于这个标准段落的意图.

或者:

• 我在正确的轨道上:函数指针必须比较相等,如果它们都指向相同的函数("地址"被诅咒),或者

• 通道中有一个冗余:函数指针必须比较相等,如果它们都指向同一个函数或两者都代表相同的地址; 并且,通过扩展,允许实现使两个函数存在于同一地址.

这是什么？

if (var != X)
  var = X;

是明智还是不合理？编译器是否总是优化if语句？是否有任何用例可以从if语句中受益？

如果var是volatile变量怎么办？

我对C++和Java答案感兴趣,因为volatile变量在两种语言中都有不同的语义.Java的JIT编译也可以带来改变.

如果我们总是用X覆盖var,那么if语句会引入分支和附加读取,所以它很糟糕.另一方面,如果var == X然后使用此优化,我们只执行读取,并且我们不执行写入,这可能会对缓存产生一些影响.显然,这里有一些权衡.我想知道它在实践中的样子.有没有人对此做过任何测试？

编辑:

我最感兴趣的是它在多处理器环境中的样子.在一个微不足道的情况下,首先检查变量似乎没有多大意义.但是,当处理器/核心之间必须保持高速缓存一致性时,额外检查可能实际上是有益的.我只是想知道它会产生多大的影响？处理器本身也不应该做这样的优化吗？如果var == X再次分配它值X不应该"弄脏"缓存.但我们可以依靠这个吗？

http://en.cppreference.com/w/cpp/atomic/memory_order和其他C++ 11在线参考,将memory_order_acquire和memory_order_release定义为:

• 获取操作:在此加载之前,不能对当前线程中的读取进行重新排序.
• 释放操作:在此存储之后,当前线程中的写入不能重新排序.

这似乎允许在获取操作之前执行获取后写入,这看起来很奇怪(通常的获取/释放操作语义限制所有内存操作的移动).

相同的在线资源(http://en.cppreference.com/w/cpp/atomic/atomic_flag)表明可以使用C++原子和上面提到的宽松内存排序规则构建自旋锁互斥:

lock mutex: while (lock.test_and_set(std::memory_order_acquire))

unlock mutex: lock.clear(std::memory_order_release);               

有了这个锁定/解锁的定义,如果确实以这种方式定义了memory_order_acquire/release,那么下面的简单代码就不会被破坏(即,不禁止对获取后写入进行重新排序):

Thread1:
  (0) lock
    (1) x = 1;
    (2) if (x != 1) PANIC
  (3) unlock

Thread2:
  (4) lock
    (5) x = 0;
  (6) unlock

以下执行是否可行:(0)锁定,(1)x = 1,(5)x = 0,(2)PANIC？我错过了什么？

我有一个std :: map包含一个类,该类有一个id.我有一个我试图在集合中找到的id

typedef std::set<LWItem> ItemSet;
ItemSet selectedItems;
LWItemID i = someID;

ItemSet::iterator isi;
isi = std::find_if(selectedItems.begin(), selectedItems.end(), [&a](LWItemID i)->bool { return a->GetID()==i; } 

我得到一个错误,说找不到lambda捕获变量,但我不知道我应该做什么来让它在迭代时捕获容器内容.另外,我知道我不能用循环来做这个,但我正在尝试学习lambda函数.

某些类型转换<type_traits>也可以使用核心语言语法表达(例如std::add_const<T>::type,/似乎等同于const T).Dtto for std::add_lvalue_reference,也许是其他人.这些类型特征有什么用？

我完全理解标准会提供一个没有它们的"不完整的工具箱",我可以想象以元方式使用,如下所示:

template<typename In, template <typename> class Modifier>
struct Apply {
  typedef typename Modifier<T>::type Out;
};

Apply<int, std::add_const>

是否存在可以在语法上表达的这些特征的任何其他用例,或者它们是否仅仅是"出于完整感"和偶尔的元使用？

我有一个很大但可能变化的对象,它们被同时写入.我想用互斥锁保护访问权限.为此,我认为我使用了一个std::vector<std::mutex>,但这不起作用,因为std::mutex没有复制或移动构造函数,同时std::vector::resize()需要.

这个难题的推荐解决方案是什么？

编辑:所有C++随机访问容器是否需要复制或移动构造函数来重新调整大小？std :: deque会帮助吗？

再次编辑

首先,感谢您的所有想法.我对避免突变和/或将它们移动到对象中的解决方案不感兴趣(我不提供细节/原因).因此,考虑到我想要一个可调数量的mutices(在没有锁定互斥锁时保证调整的情况)的问题,那么似乎有几种解决方案.

1我可以使用固定数量的mutices并使用哈希函数从对象映射到mutices(如Oblivous上尉的答案).这将导致冲突,但如果mutices的数量远大于线程数,但仍然小于对象数,则冲突的数量应该很小.

2我可以定义一个包装类(如在ComicSansMS的答案中),例如

struct mutex_wrapper : std::mutex
{
  mutex_wrapper() = default;
  mutex_wrapper(mutex_wrapper const&) noexcept : std::mutex() {}
  bool operator==(mutex_wrapper const&other) noexcept { return this==&other; }
};

并使用一个std::vector<mutex_wrapper>.

3我可以std::unique_ptr<std::mutex>用来管理单个互斥体(如Matthias的答案).这种方法的问题是每个互斥锁在堆上单独分配和解除分配.因此,我更喜欢

4 std::unique_ptr<std::mutex[]> mutices( new std::mutex[n_mutex] );

当n_mutex最初分配一定数量的mutices时.如果以后发现这个数字不够,我只是

if(need_mutex > n_mutex) {
  mutices.reset( new std::mutex[need_mutex] );
  n_mutex = need_mutex;
}

那么我应该使用这些(1,2,4)中的哪一个？