小编GMa*_*ckG的帖子

我听说临时对象只能分配给常量引用.

但是这段代码给出了错误

#include <iostream.h>    
template<class t>
t const& check(){
  return t(); //return a temporary object
}    
int main(int argc, char** argv){

const int &resCheck = check<int>(); /* fine */
typedef int& ref;
const ref error = check<int>(); / *error */
return 0;
}

得到的错误是 invalid initialization of reference of type 'int&' from expression of type 'const int'

最近在我的代码中,我已经明确地编写noexcept(false)了我知道会抛出异常的函数,主要是为了阅读代码的人.但是,我想知道这是否会影响我的代码行为或编译器解释它的方式.它有什么不同吗？

注意:我知道析构函数是隐式noexcept,你必须指定noexcept(false)更改它,我想知道其他函数.

我遇到了一个奇怪的问题.以下简化代码重现了MSVC 2010中的问题:

template <typename T>
struct dummy
{
    static T foo(void) { return T(); }
};

int main(void)
{
    typedef dummy<bool> dummy_type;
    auto x = []{ bool b = dummy_type::foo(); };
    // auto x = []{ bool b = dummy<bool>::foo(); }; // works
}

该typedef函数中本地创建的我似乎并没有在拉姆达可见.如果我用typedef实际类型替换它,它按预期工作.

以下是一些其他测试用例:

// crashes the compiler, credit to Tarydon
int main(void)
{
    struct dummy {};

    auto x = []{ dummy d; };
}

// works as expected
int main(void)
{
    typedef int …

我有一个std::multiset存储元素class A.我operator<为这个课提供了自己的实现.我的问题是,如果我在这个multiset中插入两个等效对象,他们的顺序是否有保证？例如,首先我将一个对象a1插入到集合中,然后将一个等效对象a2插入到该集合中.当我遍历集合时,我可以期待a1之前a2的结果吗？如果不是,有没有办法用multiset实现这个目的？

我在C++的应用程序中使用boost :: shared_ptr.内存问题非常严重,应用程序占用大量内存.

但是,因为我将每个新建对象放入shared_ptr,当应用程序退出时,不会检测到内存泄漏.

必须有一些像std::vector<shared_ptr<> >池持有资源的东西.调试时如何知道谁拥有shared_ptr？

很难逐行检查代码.代码太多......

非常感谢!

我正在阅读一些旧的游戏编程书籍,正如你们中的一些人可能知道的那样,在那一天,做一些黑客攻击通常比以标准方式做事更快.(转换float为int,屏蔽符号位,转换回绝对值,而不是仅调用fabs(),例如)

现在,使用标准库数学函数几乎总是更好,因为这些微小的东西无论如何都不是大多数瓶颈的原因.

但为了好奇,我仍然想做一个比较.所以我想确保在我描述时,我没有得到偏差的结果.因此,我想确保编译器不会优化没有副作用的语句,例如:

void float_to_int(float f)
{
    int i = static_cast<int>(f); // has no side-effects
}

有没有办法做到这一点？据我所知,做类似的事情i += 10仍然没有副作用,因此无法解决问题.

我唯一能想到的是拥有一个全局变量int dummy;,并且在执行类似的操作之后dummy += i,所以使用了值i.但我觉得这个虚拟操作会妨碍我想要的结果.

我正在使用Visual Studio 2008/G ++(3.4.4).

编辑

为了澄清,我希望最大限度地优化所有优化,以获得良好的个人资料结果.问题在于,由此可以优化出没有副作用的陈述,因此情况就是如此.

再次编辑

为了再次澄清,请阅读:我不是试图在某种生产代码中对其进行微观优化.

我们都知道旧的技巧不再有用了,我只是好奇他们是多么有用.只是好奇心.当然,如果不知道这些旧的黑客对现代CPU的表现如何,生活可以继续下去,但要知道它永远不会伤害.

所以告诉我"这些技巧不再有用了,不要试图微观优化等等"是一个完全忽略这一点的答案.我知道它们没用,我不使用它们.

过早引用Knuth是所有烦恼的根源.

我有一些看起来像这样的代码,其中addr是一个sockaddr*:

struct sockaddr_in *sin = (struct sockaddr_in *) addr;
const char *IP=inet_ntoa(sin -> sin_addr);

我相信这是使用Berkeley套接字的非常典型的代码.

但是,当我编译它时,我收到以下警告:
dereferencing pointer 'sin' does break strict anti-aliasing rules

在线搜索,我发现一些关于我正在做事的方式非常典型的事实的讨论,但这个编译器警告也是非常真实的并不是一件好事.

重做此代码以修复警告的正确方法是什么,而不仅仅是沉默它？

在C++ 0x(n3126)中,可以比较智能指针,无论是关系还是相等.但是,这样做的方式似乎与我不一致.

例如,shared_ptr定义operator<相当于:

template <typename T, typename U>
bool operator<(const shared_ptr<T>& a, const shared_ptr<T>& b)
{
    return std::less<void*>()(a.get(), b.get());
}

std::less与未指定的vanilla关系指针比较不同,使用提供关于指针值的总排序.

但是,unique_ptr定义相同的运算符:

template <typename T1, typename D1, typename T2, typename D2>
bool operator<(const unique_ptr<T1, D1>& a, const unique_ptr<T2, D2>& b)
{
    return a.get() < b.get();
}

它还以类似的方式定义了其他关系运算符.

为什么改变方法和"完整性"？也就是说,为什么shared_ptr使用std::less,而unique_ptr使用内置的operator<？为什么不shared_ptr提供其他关系运算符,比如unique_ptr？

我可以理解这两种选择背后的理由:

• 关于方法:它代表一个指针,所以只需使用内置指针运算符,而不是它需要在一个关联容器中使用,所以提供总排序(就像一个vanilla指针将使用默认的std::less谓词模板参数获得)
• 关于完整性:它表示一个指针,因此提供与指针相同的所有比较,而它是一个类类型,只需要比在关联容器中使用的相当,所以只提供该要求

但我不明白为什么选择会根据智能指针类型而改变.我错过了什么？

奖金/相关:std::shared_ptr似乎已经跟随boost::shared_ptr,后者省略了"按设计"的其他关系运算符(也是如此 …

我想将一些值(比如2345)分配给一个内存位置(比如说0X12AED567).可以这样做吗？

换句话说,我该如何实现以下功能？

void AssignValToPointer(uint32_t pointer, int value)
{

}

考虑:

#include <iostream>

template <typename T> T getArray( T &arr ) {
    return *arr;
}

int main() {

    int a[] = {5, 3, 6};

    std::cout << getArray(a);

}

它假设打印数组中的第一个元素但它不起作用.这是为什么？

它给了我错误:

error: no matching function for call to 'getArray(int [3])'