C++ 分配第一个不为零的值（c+；+；）

在JavaScript中，您可以编写以下代码：

var foo=value1 | | value2。

如果

value1

不为零，

value2

如果

value1

为零，则结果为新值

value1

在C++中，这个表达式被评估为<代码>真< /COD>或<代码> false 。p> 在C++中有什么方法可以模仿这个语法吗？（用于无限数量的值）

扩展它没有简单的方法。

您可以使用

这评估为

int i;

if (value1 != 0)
    i = value1;
else
    i = value2;

语法是

(condition ? trueOutput : falseOutput)

---

您可以使用编写一个通用函数来接受任意数量的参数：

#include <initializer_list>
#include <iostream>

int find_first(std::initializer_list<int> args) {
  for(int arg : args) {
    if (arg) {
      return arg;
    }
  }
  return -1;
}

int main(int argc, char** argv) {
  std::cout << find_first({0, 0, 1, 2}) << std::endl;
  std::cout << find_first({3}) << std::endl;
  std::cout << find_first({-1, -2, 0}) << std::endl;
  return 0;
}

---

好的，到目前为止，我能想到的最好的办法是改进jterrace解决方案：）到目前为止，它使用的是可以从int分配的Foo类型。这允许解决方案使用由多个类型的对象组成的列表，这些对象都可以与Foo进行比较

有什么我可以进一步改进的，使之成为最通用的解决方案吗

    #include <initializer_list>
#include <iostream>
#include <stdio.h>

class Foo {
public:
    Foo(int v){val = v;}
    bool operator==(int v) const {return val == v;}
    bool operator!=(int v) const {return val != v;}
    operator int() const {return val;}
    int val; 
};

template<class Type>
Type find_first(std::initializer_list<Type> args) {
    auto it = args.begin(); 
    for(int c = 0; c < args.size(); c++) {
        if (*it != 0) {
            return *it;
        }
        if(c == args.size() - 1) return *it; 
        it++; 
    }
    // only get here if size == 0
    return Type(0);
}

int main(int argc, char** argv) {
    Foo *foo = new Foo(0);
    Foo bar = 0; 
    std::cout << find_first<Foo>({*foo, bar, 1}).val << std::endl;
    std::cout << find_first<int>({*foo, bar, (int)3.0f}) << std::endl; 
    return 0;
}

#包括
#包括
#包括
福班{
公众：
Foo（intv）{val=v；}
布尔运算符==（int v）常量{return val==v；}
布尔运算符！=（int v）const{return val！=v；}
运算符int（）常量{return val；}
int-val；
};
模板
键入find_first（std:：initializer_list args）{
auto it=args.begin（）；
对于（int c=0；cstd:：cout这个假设表达式的类型应该是什么？不应该是
value1！=0
？@Biffen Yeah haha意识到重新阅读问题检查编辑器也不符合规范。如果我有10个不同的值怎么办？这不符合规范。如果两者都是真的，并且value2高于value1怎么办？它将返回value2但是应该返回值1。对，没有考虑：）更新。感谢您的提示，我改进了下面的解决方案。它确实扩展了：
auto foo=v1？v1:v2？v2:v3？v3:v4；
#include <initializer_list>
#include <iostream>

int find_first(std::initializer_list<int> args) {
  for(int arg : args) {
    if (arg) {
      return arg;
    }
  }
  return -1;
}

int main(int argc, char** argv) {
  std::cout << find_first({0, 0, 1, 2}) << std::endl;
  std::cout << find_first({3}) << std::endl;
  std::cout << find_first({-1, -2, 0}) << std::endl;
  return 0;
}

1
3
-1

    #include <initializer_list>
#include <iostream>
#include <stdio.h>

class Foo {
public:
    Foo(int v){val = v;}
    bool operator==(int v) const {return val == v;}
    bool operator!=(int v) const {return val != v;}
    operator int() const {return val;}
    int val; 
};

template<class Type>
Type find_first(std::initializer_list<Type> args) {
    auto it = args.begin(); 
    for(int c = 0; c < args.size(); c++) {
        if (*it != 0) {
            return *it;
        }
        if(c == args.size() - 1) return *it; 
        it++; 
    }
    // only get here if size == 0
    return Type(0);
}

int main(int argc, char** argv) {
    Foo *foo = new Foo(0);
    Foo bar = 0; 
    std::cout << find_first<Foo>({*foo, bar, 1}).val << std::endl;
    std::cout << find_first<int>({*foo, bar, (int)3.0f}) << std::endl; 
    return 0;
}