标签: conditional-operator

考虑到评估时间,以下是两个相当的？

if(condition1)
{
    //code1
}
else
{
    //code2
}

condition1 ? code1 : code2

或者它们只是语法上的不同？

我熟悉zipWith对两个序列的相应元素进行操作的标准函数,但是在函数式语言(或具有某些功能特性的语言)中,有条件地选择要压缩的元素对的最简洁方法是什么,基于第三顺序？

这种好奇心是在Excel中剔除一些东西时产生的.
A1中有数字:A10,B1:B10,C1:C10,D1,E1和F1,我使用的公式如下:

{=AVERAGE(IF((D1<=(A1:A10))*((A1:A10)<=E1),B1:B10/C1:C10))}

IF语句中乘法的每一半都将产生一个布尔值数组,然后将它们相乘(和).那些布尔人控制十个商中的哪一个最终将被平均,所以就好像正在评估10个单独的IF语句.

例如,如果A1:A10中的10个值中只有第二个和第三个满足条件(> = D1和<= E1),那么公式最终会得到评估:

AVERAGE(FALSE,B2/C2,B3/C3,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE)

AVERAGE函数碰巧忽略了布尔值和文本值,所以我们只得到第二和第三商的平均值.

这可以用Haskell简洁地完成吗？二郎？LINQ还是F#？蟒蛇？等等..

请注意,对于此特定示例,上面给出的公式并不完全正确 - 它缩写为获得基本点.当A1:A10中的十个元素都不满足条件时,则将十个FALSE值传递给AVERAGE,这将错误地计算为0.
公式应该这样写:

{=AVERAGE(IF(NOT(OR((D1<=(A1:A10))*((A1:A10)<=E1))),NA(),
             IF((D1<=(A1:A10))*((A1:A10)<=E1),B1:B10/C1:C10)))}

当NA()产生一个错误,这表明平均是未定义的.

更新:

谢谢你的回答.我意识到,当第一个列表中的相应元素符合某些特定条件时,在第二个和第三个列表中对元素对应用函数时,我的第一个问题非常简单.我接受了Norman Ramsey的答案.

然而,我去的下一步是想知道该函数是否可以应用于表示来自任意数量列表的相应元素的元组 - 因此我向Lebertram提出了关于限制的问题zipWithN.

Apocalisp关于applicative functor的信息让我了解了python对参数列表的解包 - 将函数应用于任意数量的参数.

对于我上面给出的具体示例,平均列表元素的商(其中nums是列表列表),看起来像python可以这样做:

from operator import div

def avg(a): return sum(a,0.0)/len(a)
avg([reduce(div,t[1:]) for t in zip(*nums) if d<=t[0] and t[0]<=e])

更一般地说,使用函数f和谓词p(以及avg),这将成为:

avg([f(t[1:]) for t in zip(*nums) if p(t[0])])

考虑以下代码:

int i, k, m;
k = 12;
m = 34;
for (i = 0; i < 2; i++) ((i & 1) ? k : m) = 99 - i;
printf("k: %ld   m: %ld\n\n", k, m);

在这个愚蠢的例子中,条件运算符表达式是一个快捷方式:

if (i & 1) k = 99 - i; else m = 99 - i;

我的编译器没有抱怨并执行这段代码给出了预期的输出

k: 98   m: 99

不过,我的问题是,如果这是符合C标准的有效代码吗？我以前从未见过这样的东西.

读完这篇文章后,我开始认为我已经学会了一个战利品printf().突然,我发现从下面的代码片段这本书:

int main()
{
    char str[]="Hello";
    int i=5,j=10;
    printf(i>j?"%50s":"%s",str); //unable to understand this 
    return 0;
}

令人惊讶的是,上面的代码运行没有错误,它打印Hello.根据我的知识,以下是语法printf():

int printf(const char *format,argument_list);

所以根据这种语法,printf()应该从格式字符串开始.但正如您在上面的代码中printf()所看到的那样i>j. 这是否意味着我在解释printf()的语法时出错了？将三元运算符放在printf()中是一种特殊情况吗？

编辑

我知道三元运算符我问的第一个参数printf()应该是const char*,我似乎不在我的例子中.

我们有一个针对我们的代码运行的程序,以遵守一些编码标准.

该计划说:

表达式不应该太复杂,减少使用的条件运算符的数量,他的表达式Min允许3.

如何减少条件运算符的数量？也许把关键事件放在一个数组中？

public boolean onlyNumbers(KeyEvent evt) {
    char c = evt.getKeyChar();
    boolean returnValue = true;
    if (
        !(
            Character.isDigit(c) 
            || c == KeyEvent.VK_BACK_SPACE
            || c == KeyEvent.VK_DELETE 
            || c == KeyEvent.VK_END 
            || c == KeyEvent.VK_HOME
        )
        || c == KeyEvent.VK_PAGE_UP
        || c == KeyEvent.VK_PAGE_DOWN
        || c == KeyEvent.VK_INSERT
    ) {
        evt.consume();
        returnValue = false;
    }
    return returnValue;
}

这在eclipse IDE中出错.(错误符号出现在行号附近)

String[] allText = null;

在此之后我做了一些事情,比如初始化数组等等.但根据一些条件.所以我想使用如下的条件运算符.

List<String> finalText = (allText != null) ?
    Arrays.asList(allText) : (List<String>) Collections.emptyList();

如果我在等号之后放置我的铸件,它运行良好.(包装完整的三元操作)这个错误的目的是什么？

List<String> allHotels = (List<String>) ((allText != null) ?
    Arrays.asList(allText) : Collections.emptyList());

当阅读有关 auto 和 decltype (C++11) 的内容时，我看到以下函数

auto findMin(A a, B b) -> decltype(a < b ? a : b)
{
    return (a < b) ? a : b;
}

这部分 -> decltype(a < b ? a : b) 对我来说很奇怪。什么样的函数声明或者它只适用于 auto 和 decltype ？

以下代码在 C 语言中有效/良好实践吗？

int x = 1;
printf(x == 1 ? "%d second elapsed" : "%d seconds elapsed", x);

它编译得很好，所以我认为它很好（也因为它只是 if-else 块的语法糖），但如果有人有一些额外的见解，我将不胜感激，谢谢。

PS，我想 C++ 也是如此？

我正在使用std::moveon编写一些 C++ 代码shared_ptr，并得到了非常奇怪的输出。我简化了我的代码如下

int func(std::shared_ptr<int>&& a) {
    return 0;
}

int main() {
    std::shared_ptr<int> ptr = std::make_shared<int>(1);

    for (int i = 0; i != 10; ++i) {
        func(i == 9 ? std::move(ptr) : std::shared_ptr<int>(ptr));
    }

    if (ptr) {
        std::cout << "ptr is not null: " << *ptr << "\n";
    } else {
        std::cout << "ptr is null\n";
    }

    return 0;
}

我得到了输出

ptr is null

正如我所预期的，我的ptrwill 在最后一个循环中被移动（转换为std::shared_ptr<int>&&），并且由于func从不窃取 中的内存a，所以我的 …

为什么两个结果打印出来是一样的？

final list1 = [ "a", "b", "c" ];
final result1 = true ? list1 : list1..removeWhere((e) => e == "a");
print(result1); // prints ["b", "c"]

final list2 = [ "a", "b", "c" ];
final result2 = false ? list2 : list2..removeWhere((e) => e == "a");
print(result2); // prints ["b", "c"]

这种情况仅发生在三元条件下。当在正常的 if-else 中时，这工作得很好。