小编Naw*_*waz的帖子

我很好奇这两个二级索引和它们之间的差异.很难想象这是怎么回事.而且我认为,这将有助于更多的人而不仅仅是我.

哪个值更好用？布尔值是真还是整数1？

上面的话题让我做一些实验与bool和int的if状态.所以出于好奇我写了这个程序:

int f(int i) 
{
    if ( i ) return 99;   //if(int)
    else  return -99;
}
int g(bool b)
{
    if ( b ) return 99;   //if(bool)
    else  return -99;
}
int main(){}

g++ intbool.cpp -S 为每个函数生成asm代码,如下所示:

• asm代码 f(int)

  __Z1fi:
     LFB0:
           pushl  %ebp
     LCFI0:
            movl  %esp, %ebp
     LCFI1:
            cmpl  $0, 8(%ebp)
            je    L2
            movl  $99, %eax
            jmp   L3
     L2:
            movl  $-99, %eax
     L3:
            leave
     LCFI2:
            ret
  

  Run Code Online (Sandbox Code Playgroud)

• asm代码 g(bool)

  __Z1gb:
     LFB1:
            pushl %ebp
     LCFI3: …

  Run Code Online (Sandbox Code Playgroud)

我经常遇到如下代码:

if ( items != null)
{
   foreach(T item in items)
   {
        //...
   }
}

基本上,if条件确保foreach块仅在items不为null时才会执行.我想知道这种if情况是否真的需要,或者foreach是否会处理这种情况items == null.

我的意思是,我可以简单地写一下

foreach(T item in items)
{
    //...
}

不用担心是否items为空？是if条件多余的？或者这取决于该类型的items或可能的T呢？

我想在一行中创建给定列表中的字典.字典的键将是索引,值将是列表的元素.像这样的东西:

a = [51,27,13,56]         #given list

d = one-line-statement    #one line statement to create dictionary

print(d)

输出:

{0:51, 1:27, 2:13, 3:56}

我没有任何具体的要求,为什么我要一个线.我只是在探索python,并想知道这是否可行.

C++标准中的$ 7.3.1.1/2节描述如下:

在声明命名空间作用域中的对象时,不推荐使用static关键字; unnamed-namespace提供了一个更好的选择.

我不明白为什么一个未命名的命名空间被认为是一个更好的选择？理由是什么？我已经知道标准的内容很长一段时间,但我从未认真考虑过,即使我回答这个问题:未命名的命名空间优于静态？

它是否被认为是优越的,因为它也可以应用于用户定义的类型,正如我在回答中所描述的那样？还是有其他原因,我不知道？我问这个问题,特别是因为这是我在答案中的推理,而标准可能会考虑其他因素.

我一直在读句子

不要依赖大小为8位的1字节

使用CHAR_BIT而不是8作为常量来转换位和字节

等等.今天有什么现实生活系统,这是真的吗？ _{(我不确定C和C++之间是否存在差异,或者它是否与语言无关.如果需要,请重新加入.)}

将此主题视为以下主题的续篇:

上一部分
未定义的行为和序列点

让我们重新审视这个有趣而复杂的表达(斜体短语取自上述主题*smile*):

i += ++i;

我们说这会调用undefined-behavior.我假定说这个的时候,我们隐含假设型的i是内置的类型之一.

如果什么类型的i是用户定义类型？比如它的类型是Index在本文后面定义的(见下文).它还会调用未定义的行为吗？

如果是,为什么？它不等同于写作i.operator+=(i.operator++());甚至语法上更简单 i.add(i.inc());吗？或者,他们是否也调用未定义的行为？

如果不是,为什么不呢？毕竟,对象在连续的序列点之间i被修改两次.请回想一下经验法则:表达式只能在连续的"序列点"之间修改一个对象的值.如果 i += ++i是表达式,那么它必须调用未定义的行为.如果是,那么它的等价物i.operator+=(i.operator++());也 i.add(i.inc());必须调用undefined-behavior似乎是不真实的!(据我所知)

或者,i += ++i不是一个开头的表达？如果是这样,那么它是什么以及表达式的定义是什么？

如果它是一个表达式,并在同一时间,其行为也是定义良好的,那么就意味着与表达相关序列点的数量在某种程度上取决于该类型的参与表达操作数.我是否正确(甚至部分)？

顺便问一下,这个表达怎么样？

//Consider two cases:
//1. If a is an array of a built-in type
//2. If a is user-defined type which overloads the …

我试图创建一个lambda矢量,但失败了:

auto ignore = [&]() { return 10; };  //1
std::vector<decltype(ignore)> v;     //2
v.push_back([&]() { return 100; });  //3

直到第2行,它编译得很好.但第3行给出了编译错误:

错误:没有匹配函数来调用'std :: vector <main():: <lambda()>> :: push_back(main():: <lambda()>)'

我不想要一个函数指针向量或函数对象向量.但是,封装真实 lambda表达式的函数对象向量对我有用.这可能吗？

在我的脚本中,requests.get永远不会返回:

import requests

print ("requesting..")

# This call never returns!
r = requests.get(
    "http://www.justdial.com",
    proxies = {'http': '222.255.169.74:8080'},
)

print(r.ok)

可能的原因是什么？任何补救措施？get使用的默认超时是多少？

我知道语言规范禁止功能模板的部分特化.

我想知道为什么禁止它的理由？它们没用吗？

template<typename T, typename U> void f() {}   //allowed!
template<> void f<int, char>()            {}   //allowed!
template<typename T> void f<char, T>()    {}   //not allowed!
template<typename T> void f<T, int>()     {}   //not allowed!