C++11 条件数据类型

Question

I wrote a C++11 function that conditionally initializes an object. Consider the following example:

arma::mat some_function(bool a, bool b, unsigned long int c) {
  if(a) {
    if(b) {
      arma::sp_mat d(c, c);
    } else {
      arma::SpMat<short> d(c, c);
    }
  } else {
    if(b) {
      arma::mat d(c, c, fill::zeros);
    } else {
      arma::Mat<short> d(c, c, fill::zeros);
    }
  }
  // Some other computations and a return statement
}

As you can see, I want to initialize an object d where the (Armadillo) data type depends on booleans a and b . Unfortunately, it does not compile, with the compiler complaining about d not being declared in the scope where it is subsequently used.

I found various discussions on similar issues. Conditional initialization is apparently introduced in C++17. However, I need to use C++11 in this application. Other suggestions mention the type_traits library and lambda functions. And many discussions focus on conditionally specifying the object's content rather than its data type. As I am still fairly new to C++, I am not sure how to apply any of these options to the this nested conditional structure.

Answer 1

template<class F>
arma::mat some_function(bool a, bool b, unsigned long int c, F f) {
  if(a) {
    if(b) {
      arma::sp_mat d(c, c);
      return f(d);
    }
    arma::SpMat<short> d(c, c);
    return f(d);
  }
  if(b) {
    arma::mat d(c, c, fill::zeros);
    return f(d);
  }
  arma::Mat<short> d(c, c, fill::zeros);
  return f(d);
}

arma::mat some_function(bool a, bool b, unsigned long int c){
  return some_function(a, b, c,
    [](auto&& d)->arma::mat{
      // Some other computations and a return statement
    }
  );
}

I believe this solves your problem, but requires c++14 .

The style here is called "continuation passing style"; the first template creates the variable d , then passes that to a function you passed to it. It then returns what the function it takes returns when it in turn takes a d .

The code within the lambda at the bottom must be able to handle d being any of the types it could be within the template function, because it doesn't know what the bool values will be.

(If the bool values are known there are other approaches, but often the answer is "if you know that, and only some are valid, why do the bools exist?)

The c++14 feature was so simple to write most c++11 compilers support it if you tell it to use c++1y (their early pre-standard version of C++14). If not, you can just replace this:

    [](auto&& d)->arma::mat{
      // Some other computations and a return statement
    }

with

struct some_helper {
  template<class M>
  arma::mat operator()(M&& m)const {
    // Some other computations and a return statement
  }
};

outside of some_function , then

arma::mat some_function(bool a, bool b, unsigned long int c){
  return some_function(a, b, c,
    some_helper{}
  );
}

In the c++14 case, if you need access to a/b/c, change [] to [&] .

In the c++11 case, if you need access to a/b/c, add them to some_helper as member variables (or references) and initialize them in some_helper 's constructor, and pass them in from some_function .

The c++14 feature I'm using is the terse syntax templated lambda, which is syntactic sugar to generate the trivial c++11 class. The c++14 lambda has a few more (zero cost) features we don't care about.

Answer 2

You'll probably need to put the common code in a template function which can be instantiated for all 4 different types. Then, in all 4 branches, call this template. The compiler will generate 4 different instantiations.

Answer 3

You need "the rest of the computations" in the same block as the different variable definitions. There are cases that use different types; I expect that the code then uses only the same one you showed being defined. Clearly that code can be separate. You also showed two cases where different constructors are called for the same type; subsequent code can use the same variable, once it had been created.

But since you didn't show the rest of the code, I don't know: is there any common processing among the four cases? Any common code can go into subroutines.

arma::mat some_function(bool a, bool b, unsigned long int c) {
  if(a) {
    if(b) {
      arma::sp_mat d(c, c);
        // Some other computations and a return statement
    } else {
      arma::SpMat<short> d(c, c);
        // Some other computations and a return statement
    }
  } else {
    if(b) {
      arma::mat d(c, c, fill::zeros);
        // Some other computations and a return statement
    } else {
      arma::Mat<short> d(c, c, fill::zeros);
        // Some other computations and a return statement
    }
  }
// no return here; unreachable.
}

The "other computations" each see their own variable. If there is a lot of commonality among those four branches, put it in a common subroutine that they can all call.