我正在阅读内核代码，并且在一个地方我看到了if语句中的一个表达式，例如
if (value == (SPINLOCK_SHARED | 1) - 1) {
............
}
其中SPINLOCK_SHARED = 0x80000000是预定义的常量。
我想知道为什么我们需要(SPINLOCK_SHARED | 1) - 1- 用于类型转换目的？表达式的结果将是 80000000-- 与 0x80000000 相同，不是吗？然而，为什么 ORing 1 和 Subtracting 1 很重要？
有一种感觉，我想得到一些东西..
我一直在阅读Scott关于c ++ 11和14的最后一篇大师文章中的通用引用,尽管有一个参数分配给左值或右值类型的参考参数,但在它们之间存在一些被称为通用引用的东西,它可以推导出来l/rvalue基于传递的参数的类型特征.我可以理解是什么使得参数成为通用引用但是我不清楚的一个原因是为什么在类型参数中添加const const T&& p使得p为rvalue:
template<typename T>
void f(T&& param); // param is an universal reference
template<typename T>
void f(const T&& param); // param is an rvalue reference
const分配给参考参数时,是否会执行此操作.
我试着通过阅读这篇博客来了解零的规则.IMO,它说如果你声明自己的析构函数,那么不要忘记创建移动构造函数并将赋值移动为默认值.
示例:
class Widget {
public:
~Widget(); // temporary destructor
... // no copy or move functions
};
"添加析构函数会产生禁用生成移动函数的副作用,但由于Widget是可复制的,因此用于生成移动的所有代码现在都会生成副本.换句话说,向类中添加析构函数可能会导致 - 有效的动作可以用可能效率低下的副本无声地替换".
Scott Meyers的上述文字在引言中提出了一些问题:
我主要在C++中做事,其中析构函数方法实际上是用于破坏获得的资源.最近我开始使用python(这真的很有趣也很棒),我开始学习它像GC一样的GC.因此,没有强调对象所有权(构造和破坏).
据我所知,这个 __init__()方法在python中对我来说比对ruby更有意义,但是__del__()方法,我们真的需要在我们的类中实现这个内置函数吗？如果我想念,我的班级会缺少什么__del__()？我可以看到__del__()有用的一个场景是,如果我想在销毁对象时记录某些内容.除此之外还有什么吗？
我只是想知道python中空类大小背后的基本原理,在C++中,每个人都知道空类的大小总是显示1个字节(据我所知)这让运行时创建独特的对象,而我试图找出python中空类的大小:
class Empty:pass # i hope this will create empty class
当我这样做的时候
import sys
print ("show",sys.getsizeof(Empty)) # i get 1016
我想知道为什么Empty需要这么多1016(字节)？并且它返回的值(1016)是否是一个永远不会像C++一样改变的标准值？我们是否期望从python解释器中进行任何零基类优化？有没有什么办法可以减小am的大小(只是出于好奇心缘故)？
我已经在库实现中看到了这个表达式,我基本上理解它已被用于培养SFINAE甚至是static_assert触发器.
它基本上采取以下形式:
template <typename>
char (&checkValid(...))[2];
template <typename T>
char checkValid(e); where e is an expression(using type T) results in type X
如果e结构良好,那么结果将是(假设使用sizeof)1 else 2并且可以应用于:
static_assert(sizeof(checkValid<T>(0))==1,"") ;
有一天,我一直以不同的方式做类似的事情:
using namespace std;
template<typename...T>
using isValid = void;
template<typename>
false_type checkValid(...);
template<typename T>
true_type checkValid(isValid<typename T::type>*);
struct some{
using type = int;
};
int main(){
constexpr bool result = decltype(checkValid<some>(0))::value;
}
无论我做了什么和看到了什么,我都更加好奇知道:
这个表达式叫做什么？
template <typename>
char (&checkValid(...))[2];
"变量模板"？"功能模板？" 或者"参考......的阵列"？(对不起,如果我猜的很糟糕)
在seastar框架中看到过这段代码
template <typename Func>
class lambda_task final : public task {
Func _func;
public:
lambda_task(scheduling_group sg, const Func& func) : task(sg),
_func(func) {}
lambda_task(scheduling_group sg, Func&& func) : task(sg),
_func(std::move(func)) {}
virtual void run_and_dispose() noexcept override {
_func();
delete this;
}
};
template <typename Func>
inline std::unique_ptr<task> make_task(Func&& func) {
return std::make_unique<lambda_task<Func>>(current_scheduling_group(),
std::forward<Func>(func));
}
using scheduling_group = int;
auto current_scheduling_group(){ return int{};}//为了简单起见
让我们假设我将实例化task如下
auto work = [](){...}
make_task(work);
如此以来,work为lvalue make_task(Func&&)- > …
我正在尝试一些线程代码,我虽然使用quick_exit函数来终止程序而不清理资源,下面是我的代码.
#include<future>
#include<iostream>
#include<thread> // std::thread, std::this_thread::sleep_for
#include<chrono>
#include<cstdlib>
using namespace std;
static void pause_thread(int n)
{
std::this_thread::sleep_for (std::chrono::seconds(n));
std::cout << "pause of " << n << " seconds ended\n";
}
int main()
{
std::cout << "Spawning and detaching 3 threads...\n";
std::thread (pause_thread,5).detach();
std::thread (pause_thread,8).detach();
std::thread (pause_thread,9).detach();
std::cout << "Done spawning threads.\n";
std::cout << "(the main thread will now pause for 2 seconds)\n";
// give the detached threads time to finish (but not guaranteed!):
pause_thread(2);
quick_exit(0); //here is the problem,was …它可能听起来很虚,但是,有点混乱,我已经经历了这个问题,当我们看到它们在同样的情况下,我必须使我的map静态所以它将是所有实例将是共同的在单独创建的threads,我要同步要去我的地图的行为的功能,所以我想制作的std::mutex是static在我的课像有人提出什么作为给定链路的答案.在这种情况下,会不会有任何竞争条件是为了获取和锁定mutex自己？是否有更好的方法可以同步static map使用的功能mutex
只是为了证实我的理解 std::move
std::move-转换T&到T&&,这样的T's举动构造会踢(如果它已经存在,否则拷贝构造函数会发挥它的作用,除非我们不是外部被删除的举动构造函数/分配).
当我看到std::move它的可能实现时
template<typename T>
typename remove_reference<T>::type&& move(T&& param)
{
using ReturnType =typename remove_reference<T>::type&&;
return static_cast<ReturnType>(param);
}
它使用的原因remove_reference<T>是因为在forward_reference上应用了引用折叠T&&
我只是想知道为什么我们需要前向参考,我们不能这样做
template<typename T>
T&& moveInQuestion(T& p){
return static_cast<T&&>(p);
}
struct someType{};
someType lvalref;
static_assert(is_same<decltype(moveInQuestion(lvalref)),decltype(std::move(lvalref))>::value,"");
static_assert 没有失败.
而且我也相信,意味着的价值类别std::move是lvalue这样的情况moveInQuestion可能会好于std::move？