Construct or_exprt in a non-deprecated way

The default constructor is deprecated. To facilitate construction with an
arbitrary number of operands a new constructor taking a initializer list is
added.

Author: tautschnig

src/goto-symex/memory_model.cpp

@@ -119,8 +119,7 @@ void memory_model_baset::read_from(symex_target_equationt &equation)
         rf_some=rf_some_operands.front();
       else
       {
-        rf_some=or_exprt();
-        rf_some.operands().swap(rf_some_operands);
+        rf_some = or_exprt(std::move(rf_some_operands));
       }
 
       // Add the read's guard, each of the writes' guards is implied

src/solvers/floatbv/float_bv.cpp

@@ -789,11 +789,10 @@ exprt float_bvt::relation(
     }
     else if(rel==relt::LE)
     {
-      or_exprt or_bv;
-      or_bv.reserve_operands(3);
-      or_bv.copy_to_operands(less_than3);
-      or_bv.copy_to_operands(both_zero);
-      or_bv.copy_to_operands(bitwise_equal);
+      or_exprt or_bv{{
+      less_than3,
+      both_zero,
+      bitwise_equal}};
 
       return and_exprt(or_bv, not_exprt(nan));
     }

src/solvers/prop/minimize.cpp

@@ -81,11 +81,12 @@ literalt prop_minimizet::constraint()
     return or_clause.front();
   else
   {
-    or_exprt or_expr;
+    exprt::operandst disjuncts;
+    disjuncts.reserve(or_clause.size());
     forall_literals(it, or_clause)
-      or_expr.copy_to_operands(literal_exprt(*it));
+      disjuncts.push_back(literal_exprt(*it));
 
-    return prop_conv.convert(or_expr);
+    return prop_conv.convert(disjunction(disjuncts));
   }
 }
 

src/util/std_expr.cpp

@@ -31,9 +31,7 @@ exprt disjunction(const exprt::operandst &op)
     return op.front();
   else
   {
-    or_exprt result;
-    result.operands()=op;
-    return std::move(result);
+    return or_exprt(exprt::operandst(op));
   }
 }
 

src/util/std_expr.h

@@ -2588,6 +2588,11 @@ class or_exprt:public multi_ary_exprt
     : multi_ary_exprt(ID_or, {op0, op1, op2, op3}, bool_typet())
   {
   }
+
+  or_exprt(exprt::operandst &&_operands)
+    : multi_ary_exprt(ID_or, std::move(_operands), bool_typet())
+  {
+  }
 };
 
 /// 1) generates a disjunction for two or more operands