在 c++ 中实现嵌套循环的任何更短的方法？

Question

For example, if we want a program to do the following:

    int sum=0;
    for(int a=0; a<10; ++a)
    for(int b=0; b<10; ++b)
    for(int c=0; c<10; ++c)
    for(int d=0; d<1-; ++d)
    sum+=max(max(a,b),max(c,d));

Here,it's fine as for now because there are only 3 nested loops. My question is if we had for example 20 nested loops to deal with, Is there a way we can cut short the efforts?

Answer 1

you can use a recursion and an array for loop vars, something like the following. I just suggest not to use 10 in the loop or you will wait for your results forever:-)

#include <iostream>
using namespace std;

int loopVar[20] = {0};

int summarize(int i){
  if (i == 20)
    return 0;
  int sum = 0;
  for(loopVar[i] = 0; loopVar[i] < 2; loopVar[i]++)
      sum += summarize(i+1);
  
  return sum + max(loopVar[3], loopVar[5]);
}

int main() {
  cout << summarize(0) << endl;
  return 0;
}

Answer 2

A SuperInteger class made of many sub indexes, and an Index classn using the a begin and end of SuperInteger Class type, maybe used to write a main with a unique for loop (SuperIntegers with 1 sub index more should be used now to be sure the last element exists)

This mathematic result is also used (trivial demonstration):

max (max (a, b), (max (c,d)) == max (a, b, c, d)

Using this Index and Super Integer, sum calculated is 74667 like with nested loops, (a final max_subindex () has to be performed after the loop):

int main (int argc, char * argv []) {
  //m = max (max (i, j), max (k, l) <=> m = max (i, j, k, l)
  SuperInteger beg (5, 0, 0, 0, 0), end (5, 10, 10, 10, 10, 1);
  Index index (beg, end);
  int sum (0);
  for (; !index.end (); ++index) {
    sum += index.max_subindex ();
  }
  sum += index.max_subindex ();
  std::cout << "sum == " << sum << std::endl;
  //sum == 74667
}

And the SuperInteger class:

#include <stdarg.h>
#include <iostream>
#define MAXSUBINDEX 100

class SuperInteger {
  friend class Index;
public :
  SuperInteger (int siz, ...) : size_ (siz) {
    va_list ap;
    va_start(ap, siz);
    int* pval ((int*) val_);
    for(int i = 1; i <= siz; i++, ++pval) {
        *pval = va_arg (ap, int);
    }
    va_end(ap);    
  }

  ~SuperInteger () {}
  SuperInteger (const SuperInteger& pn) : size_ (pn.size_) {
    size_ = pn.size_;
    int* p ((int*)val_);
    const int* q ((const int*) pn.val_);
    for (int i (0); i != size_; ++i, ++p, ++q) *p = *q;
  }

  SuperInteger& operator = (const SuperInteger& pn) {
    size_ = pn.size_;
    int* p ((int*)val_);
    const int* q ((const int*) pn.val_);
    for (int i (0); i != size_; ++i, ++p, ++q) *p = *q;
    return *this;
  }

  bool operator == (const SuperInteger& pn) const {
    if (size_ != pn.size_) return false;
    const int* p ((const int*)val_);
    const int* q ((const int*)pn.val_);
    for (int i (0); i != size_; ++i, ++p, ++q) if (*p != *q) return false;
    return true;
  }

  bool operator != (const SuperInteger& pn) const {
    return !operator == (pn);
  }
#ifdef _DEBUG 
  void write (std::ostream& os) const {
    const int* p ((const int*)val_);
    for (int i (0); i != size_; ++i, ++p) {os << *p << " ";}
  }
#endif

  int operator [] (const int& i) const {
    return val_ [i];
  }
  int& operator [] (const int& i) {
    return val_ [i];
  }

  int max_subindex () const {
    int m (0);
    const int* p ((const int*) val_);
    for (int i (0); i != size_; ++i, ++p)if (*p>m) m = *p;
    return m;
  }

//private :
  int size_;
  int val_ [MAXSUBINDEX];
};

and finally, the Index class, with a preincrementation method

class Index {
public :
  Index (SuperInteger beg, SuperInteger end) : beg_ (beg), val_ (beg), end_ (end) {}
  Index (const Index& i) : beg_ (i.beg_), val_ (i.val_), end_ (i.end_) {}
  Index& operator = (const Index& i) {
    beg_ = i.beg_;
    val_ = i.val_;
    end_ = i.end_;
    return *this;
  }
  bool operator == (const Index& i) const {
    return (val_ == i.val_?true:false);
  }
  bool operator != (const Index& i) const {
    return !operator == (i);
  }

  void operator ++ () {
    bool carry (true);
    int i (0); //, j (i);
    while (carry) {
      if (val_ [i] +1 < end_ [i]) {
        ++val_ [i];
        carry = false;
      }
      else {
        val_ [i] = beg_ [i];
        ++i;
      }
    }
  }
  bool end () const {
    for ( int i (0); i != val_.size_; ++i) {
      if (val_ [i] +1 != end_ [i]) return false;
    }
    return true;
  }
  int max_subindex () const {
    return val_.max_subindex ();
  }
#ifdef _DEBUG
  void write (std::ostream& os) {
    val_.write (os);
  }
#endif
  SuperInteger beg_;
  SuperInteger val_;
  SuperInteger end_;
};