小编hel*_*922的帖子

可能重复:
Visual Studio"任何CPU"目标

我注意到在VS中编译C#代码时,通常有编译32/64位系统的选项,还有一个用于编译任何cpu的选项.

这两个选项有什么区别？选择任何CPU只能编译为中间字节代码,而第一个选项编译为机器代码(这听起来不太可能)？或者是其他东西？

智能指针如何处理数组？例如,

void function(void)
{
    std::unique_ptr<int> my_array(new int[5]);
}

当my_array超出范围并被破坏时,整个整数数组是否会被重新声明？只回收了数组中的第一个元素吗？或者还有其他事情发生(例如未定义的行为)？

这是这个问题的后续问题:Lambda如何作为参数传递

据推测,MSDN已将该项标记为已修复.我看了一下规格,但是我将它们的规格转换成语法应该是什么.

例如:

void printOut(int(*eval)(int))
{
    for(int x = 0; x < 4; ++x)
    {
        std::cout << eval(x) << std::endl;
    }
}

现在说我有lambda:

auto lambda1 = [](int x)->int{return x;};

转换lambda1为等效的函数指针的语法是什么,以便可以传递给它printOut？

那么,实际上在括号中有什么东西的lambda呢？例如:

int y = 5;
auto lambda2 = [y](void)->int{return y;};

如果这种lambda无法转换为函数指针,是否有另一种方法可以将这种类型的lambda表达式传递给printOut(或者甚至是修改后的版本printOut,如果是这样的话语法是什么)？

请考虑以下示例代码:

#include <array>

struct MyClass
{
  size_t value = 0;

  constexpr static size_t size() noexcept
  {
    return 3;
  }
};

template <size_t N>
void DoIt()
{
  MyClass h;
  std::array<int, h.size()> arr;
}

int main()
{
  DoIt<1>();
}

当我尝试使用GCC 7.3.0编译它时,我得到一个关于h在非constexpr上下文中不可用的错误:

cexpr.cpp: In function ‘void DoIt()’:
cexpr.cpp:17:26: error: the value of ‘h’ is not usable in a constant expression
   std::array<int, h.size()> arr;
                          ^
cexpr.cpp:16:11: note: ‘h’ was not declared ‘constexpr’
   MyClass h;
           ^
cexpr.cpp:17:27: error: the value of ‘h’ is not usable …

在Chandler Carruth的CppCon 2015演讲中,他介绍了两种神奇的功能,可以在没有任何额外性能损失的情况下击败优化器.

作为参考,这里是函数(使用GNU样式的内联汇编):

void escape(void* p)
{
    asm volatile("" : : "g"(p) : "memory");
}

void clobber()
{
    asm volatile("" : : : "memory");
}

它适用于任何支持GNU样式内联汇编的编译器(GCC,Clang,Intel编译器,可能还有其他编译器).但是,他提到它在MSVC中不起作用.

检查Google Benchmark的实现,似乎他们使用重新解释转换为a volatile const char&并将其传递给隐藏在非gcc/clang编译器上的不同翻译单元中的函数.

template <class Tp>
inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp const& value) {
    internal::UseCharPointer(&reinterpret_cast<char const volatile&>(value));
}

// some other translation unit
void UseCharPointer(char const volatile*) {}

但是,我对此有两个顾虑:

1. 我可能会招致一个函数调用
2. 有一种"聪明"的链接时优化器可能会识别出UseCharPointer很小,内联它,然后丢弃我想要保留的所有代码,或者可以允许"聪明"的优化器执行其他重新排序我不这样做想要它.

MSVC中是否有与GNU样式的汇编函数相同的低级别？或者这是MSVC上最好的？

有谁知道任何好的教程/文章,提供QT的广泛概述？我不是在寻找一个冗长的"输入这个,这就是它做的"教程(例如诺基亚/ Troll Tech的教程,我可以看看这些东西的api文档),而是解释思想的东西制作QT应用程序的过程和注意事项(例如,将信号连接到插槽的想法,小部件是什么和不是什么,API是如何组织的等等).

如何为perf调用图启用C++ demangling？当我进入注释模式时,似乎是解码符号,而不是在主调用图中.

示例代码(使用Google Benchmark):

#include <benchmark/benchmark.h>
#include <vector>

static __attribute__ ((noinline)) int my_really_big_function()
{
  for(size_t i = 0; i < 1000; ++i)
  {
    benchmark::DoNotOptimize(i % 5);
  }
  return 0;
}

static __attribute__ ((noinline)) void caller1()
{
  for(size_t i = 0; i < 1000; ++i)
  {
    benchmark::DoNotOptimize(my_really_big_function());
    benchmark::DoNotOptimize(i % 5);
  }
}

static __attribute__ ((noinline)) void myfun(benchmark::State& state)
{
  while(state.KeepRunning())
  {
    caller1();
  }
}

BENCHMARK(myfun);

BENCHMARK_MAIN();

构建命令:

clang++ main.cpp -o main -fno-omit-frame-pointer -O0 -lpthread -lbenchmark

perf命令:

perf record -g …

共享指针(例如boost :: shared_ptr或新的std :: shared_ptr)和垃圾收集方法(例如用Java或C#实现的那些)之间有什么区别？我理解它的方式,共享指针跟踪变量指向资源的次数,并在计数达到零时自动销毁资源.但是,我的理解是垃圾收集器还管理内存资源,但需要额外的资源来确定对象是否仍然被引用,并且不一定会立即破坏资源.

我的假设是否正确,使用垃圾收集器和共享指针之间是否存在其他差异？此外,如果有人执行类似的任务但性能数据不同,为什么有人会在共享指针上使用垃圾收集器呢？

随着我对Web服务器软件的更多研究,我开始质疑Apache的基于线程/进程的方法是否可以采用Nginx和Lighttpd等服务器提供的异步请求处理方式.更重的负载更好.

据我所知,后两者和Apache之间存在许多其他差异.我的问题是在什么情况下我会选择基于线程/进程的方法来进行异步处理.

1. 是否有任何我不能使用异步方法的功能/技术(或功能不佳/不良)？

2. 什么情况会导致异步方法的性能比基于线程/进程的方法更差？这些是常见的还是罕见的情况,差异有多大？

3. 在比较两者时,还有其他因素需要考虑吗？请记住,我主要关注基于线程/进程的方法与异步,而不是任何特定的服务器软件碰巧使用这些方法之一.这些问题可能是管理/调试困难,安全问题等.

有没有办法定义从用户定义的类到基本类型(int,short等)的类型转换？此外,任何此类机制是否需要显式转换,还是隐式工作？

例如:

// simplified example class
class MyNumberClass
{
private:
    int value;
public:
    // allows for implicit type casting/promotion from int to MyNumberClass
    MyNumberClass(const int &v)
    {
        value = v;
    }
};

// defined already above
MyNumberClass t = 5;

// What's the method definition required to overload this?
int b = t; // implicit cast, b=5.
// What's the method definition required to overload this?
int c = (int) t; // C-style explicit cast, c=5.
// ... etc. for …