小编Evg*_*Evg的帖子

我无法理解阻止MPI中的通信和非阻塞通信的概念.两者有什么不同？有哪些优点和缺点？

谢谢!

给定一个排序的数组,找到max j - i这样指数之间的差异j > i,并a[j] > a[i]在O(n).我能够在复杂性中找到j并i使用琐碎的方法,O(n^2)但想知道如何做到这一点O(n)？

输入:{9,2,3,4,5,6,7,8,18,0}

输出:8(j = 8,i = 0)

输入:{1,2,3,4,5,6}

输出:5(j = 5,i = 0)

这个答案提出了以下问题。

假设我们有一个简单的

struct S {
    int& i;
}

内部（至少在 GCC 和 Clang 中）S只包含一个指向 an 的指针int，并且

static_assert(sizeof(int*) == 8);
static_assert(sizeof(S)    == 8);

是否S有唯一的对象表示？GCC 和 Clang 不同意 *：

static_assert( std::has_unique_object_representations_v<int*>);
static_assert(!std::has_unique_object_representations_v<S>);    // GCC
static_assert( std::has_unique_object_representations_v<S>);    // Clang

哪个编译器就在这里，为什么？

* idclev 463035818指出 GCC 和 Clang 之间存在分歧。

为什么std::lock_guard不可移动,它会使代码更好:

auto locked = lock_guard(mutex);

代替

std::lock_guard<std::mutex> locked(mutex);

创建自己的版本有什么问题,例如:

template <typename T> class lock_guard_
{
  T* Mutex_;
  lock_guard_(const lock_guard_&) = delete;
  lock_guard_& operator=(const lock_guard_&) = delete;
public:
  lock_guard_(T& mutex) : Mutex_(&mutex)
  {
    Mutex_->lock();
  }
  ~lock_guard_()
  {
    if(Mutex_!=nullptr)
      Mutex_->unlock();
  }
  lock_guard_(lock_guard_&& guard)
  {
    Mutex_ = guard.Mutex_;
    guard.Mutex_ = nullptr;
  }
};

template <typename T> lock_guard_<T> lock_guard(T& mutex)
{
  return lock_guard_<T>(mutex);
}

？

任何根本原因让它变得可移动是个坏主意吗？

我在一个网站上遇到过这个问题.正如那里提到的那样,在亚马逊的采访中被问到了.在给定的约束条件下,我无法找到合适的解决方案.

给定一个n整数数组,找到3个元素,a[i] < a[j] < a[k]并i < j < k在O(n)时间内.

在我研究explicit关键字之前,我的老师说:"编译器不执行连续的用户定义转换".如果是,我的代码中是否有任何错误？或者我误解了我的老师？我在VS2017工作.

#include<iostream>
#include <string>

class Myclass {
public:
    Myclass() {
        std::cout << "Myclass" << std::endl;
    }
};

class Myclass1 {
public:
    Myclass1(Myclass m) {
        std::cout << "Myclass1" << std::endl;
    }
};
class Myclass2{
public:
    Myclass2(Myclass1 m) {
        std::cout << "Myclass2" << std::endl;
    }
};

int main() {
    Myclass2 m2 = Myclass{};
} 

#include <type_traits>

template<typename... Ts>
void boo()
{
    struct A
    {
        struct B {};
    };
    static_assert(std::is_class_v<A>);
    static_assert(std::is_class_v<A::B>); // compilation failure; need typename.
}

int main()
{
    boo<int>();
}

为什么是A::B从属名称而A不是？在标准中看不到任何相关内容。

查看libstdc ++源代码，我发现以下declval实现：

template<typename _Tp, typename _Up = _Tp&&>
_Up __declval(int);  // (1)

template<typename _Tp>
_Tp __declval(long); // (2)

template<typename _Tp>
auto declval() noexcept -> decltype(__declval<_Tp>(0));

此实现是 Eric Niebler 提出的，用于优化编译时间：他解释说，重载解析比模板实例化更快。

但是，我不明白它是如何工作的。特别：

1. 在（1）中，为什么使用_Up不仅仅是返回_Tp&&？
2. 似乎从未使用过重载（2）。为什么需要它？

与最幼稚的实现相反，这一切如何防止模板实例化：

template<typename T>
T&& declval() noexcept;

Timur Doumler 在他最近的演讲“现代C ++中的类型修剪”中说，由于不能从函数返回C样式的数组，std::bit_cast因此不能用于将a进行位强制float转换unsigned char[4]。我们应该使用std::memcpy或等到C ++ 23（或更高版本）后，类似的东西reinterpret_cast<unsigned char*>(&f)[i]才能被很好地定义。

在C ++ 20中，我们可以在中std::array使用std::bit_cast，

float f = /* some value */;
auto bits = std::bit_cast<std::array<unsigned char, sizeof(float)>>(f);

而不是C样式的数组来获取float？的字节？

当我有一个循环并且在这个循环内创建一个新的堆栈变量（不将它分配在堆上并在循环体内声明它的变量），是否保证在下一次迭代开始之前调用这个对象的析构函数，或者可能编译器展开的循环会改变什么？