generate

 

#include <iostream>
using std::cout;
using std::endl;

#include <algorithm>
#include <vector>
#include <iterator>

char nextLetter();

int main()
{
   std::vector< char > chars( 10 );
   std::ostream_iterator< char > output( cout, " " );

    // generate values for all elements of chars with nextLetter
   std::generate( chars.begin(), chars.end(), nextLetter );

   cout << "\n\nVector chars after generating letters A-J:\n";
   std::copy( chars.begin(), chars.end(), output );

   cout << endl;
   return 0;
}

// generator function returns next letter (starts with A)
char nextLetter() {
   static char letter = 'A';
   return letter++;
}

/* 


Vector chars after generating letters A-J:
A B C D E F G H I J

 */ 

#include <iostream>
#include <cassert>
#include <algorithm>
#include <vector>
using namespace std;

template <typename T>
class calc_square {
  T i;
 public:
  calc_square(): i(0) {}
  T operator()() { ++i; return i * i; }
};

int main()
{
  vector<int> vector1(10);

  generate(vector1.begin(), vector1.end(), calc_square<int>());

  for (int j = 0; j < 10; ++j)
    cout << vector1[j] << " ";

  return 0;
}

/* 
1 4 9 16 25 36 49 64 81 100 
 */        
    

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

/* PRINT_ELEMENTS()
 * - prints optional C-string optcstr followed by
 * - all elements of the collection coll
 * - separated by spaces
 */
template <class T>
inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
{
    typename T::const_iterator pos;

    std::cout << optcstr;
    for (pos=coll.begin(); pos!=coll.end(); ++pos) {
        std::cout << *pos << ' ';
    }
    std::cout << std::endl;
}


class IntSequence {
  private:
    int value;
  public:
    // constructor
    IntSequence (int initialValue) : value(initialValue) {
    }

    // ''function call''
    int operator() () {
        return value++;
    }
};

int main()
{
    list<int> coll;

    // insert values from 1 to 9
    generate_n (back_inserter(coll),    // start
                9,                      // number of elements
                IntSequence(1));        // generates values

    PRINT_ELEMENTS(coll);

    // replace second to last element but one with values starting at 42
    generate (++coll.begin(),           // start
              --coll.end(),             // end
              IntSequence(42));         // generates values

    PRINT_ELEMENTS(coll);
}

/* 
1 2 3 4 5 6 7 8 9
1 42 43 44 45 46 47 48 9

 */        

#include <cstdlib>

#include <iostream>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <iterator>
#include <functional>
#include <numeric>

/* PRINT_ELEMENTS()
 * - prints optional C-string optcstr followed by
 * - all elements of the collection coll
 * - separated by spaces
 */
template <class T>
inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
{
    typename T::const_iterator pos;

    std::cout << optcstr;
    for (pos=coll.begin(); pos!=coll.end(); ++pos) {
        std::cout << *pos << ' ';
    }
    std::cout << std::endl;
}

/* INSERT_ELEMENTS (collection, first, last)
 * - fill values from first to last into the collection
 * - NOTE: NO half-open range
 */
template <class T>
inline void INSERT_ELEMENTS (T& coll, int first, int last)
{
    for (int i=first; i<=last; ++i) {
        coll.insert(coll.end(),i);
    }
}

using namespace std;

int main()
{
    list<int> coll;

    // insert five random numbers
    generate_n (back_inserter(coll),      // beginning of destination range
                5,                        // count
                rand);                    // new value generator

    // overwrite with five new random numbers
    generate (coll.begin(), coll.end(),   // destination range
              rand);                      // new value generator
    PRINT_ELEMENTS(coll);

}

/* 
15724 11478 29358 26962 24464

 */