generate(), generate_n()

Module:  Standard C++ Library   Library:  Algorithms

Function

• Local Index
• Summary
• Synopsis
• Description
• Complexity
• Example
• See Also
• Standards Conformance

Algorithm that assigns each element in a range a value produced by repeated application of the given function object

#include <algorithm>

namespace std {
  template <class ForwardIterator, class Generator>
  void generate(ForwardIterator start, ForwardIterator finish,
                Generator gen);

  template <class OutputIterator, class Size, class Generator>
  void generate_n(OutputIterator start, Size n,
                  Generator gen);
}

A value-generator function returns a value each time it is invoked. The algorithms generate() and generate_n() assign each element in the sequence [start, finish) or [start, start + n) the return value of the generator function gen(). The function gen() takes no arguments. (gen() can be a function or a class with an operator() defined that takes no arguments.)

generate_n() assumes that all iterators in the range [start, start + n] are dereferenceable, unless start is an insert iterator.

The generate() and generate_n() algorithms invoke gen() and assign its return value exactly finish - start (or n) times.

//
// generate.cpp
//

#include <algorithm>    // for generate, generate_n
#include <iostream>     // for cout, endl
#include <vector>       // for vector



// Value generator simply doubles the current value 
// and returns it.
template <class T>
class generator
{
    T val_;
public:
    generator(const T &val) : val_ (val) { }
    T operator()() {
        return val_ += val_;
    }
};


int main ()
{
    // Typedef for convenience.
    typedef std::vector<short, 
                        std::allocator<short> > vector;

    vector::value_type arr[4] = { 1, 2, 3, 4 };

    // Set up two vectors.
    vector v1(arr, arr + sizeof arr / sizeof *arr);
    vector v2 = v1;

    // Set up one empty vector.
    vector v3;

    // Create a generator function object.
    generator<vector::value_type> gen(1);

    // Generate values for all of v1.
    std::generate(v1.begin(), v1.end(), gen);

    // Generate values for first 3 of v2.
    std::generate_n(v2.begin(), 3, gen);

    // Use back_insert_iterator to generate 5 values for v3.
    std::generate_n(std::back_inserter(v3), 5, gen);

    // Copy all three to cout.
    std::ostream_iterator<vector::value_type, char,
             std::char_traits<char> > out(std::cout, " ");

    std::copy(v1.begin(), v1.end(), out);
    std::cout << std::endl;

    std::copy(v2.begin(), v2.end(), out);
    std::cout << std::endl;

    std::copy(v3.begin(), v3.end(), out);
    std::cout << std::endl;

    // Generate 3 values into cout.
    std::generate_n(out, 3, gen);
    std::cout << std::endl;

    return 0;
}


Program Output:

2 4 8 16 
2 4 8 4 
2 4 8 16 32 
2 4 8 

Function Objects

ISO/IEC 14882:1998 -- International Standard for Information Systems -- Programming Language C++, Section 25.2.6

Copyright (c) 1994-2006 Rogue Wave Software, a Quovadx Division.
Licensed under the Apache License, Version 2.0.
Contact Rogue Wave about documentation or support issues. You can also seek help from other developers through the Apache stdcxx community (see below).