بخش ۱۷ - کتابخانه‌ی STL

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

int main() {
    vector<int> v;
    v.push_back(10);
    v.push_back(123);
    v.push_back(87);

    vector<int>::iterator it = v.begin();
    while (it != v.end()) {
        cout << *it << ' ';
        ++it;
    }
    cout << endl;

    for (vector<int>::iterator it2 = v.begin(); it2 != v.end(); ++it2)
        cout << *it2 << ' ';
    cout << endl;
}
					

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
using namespace std;

/*
template<typename I, typename T>
I find(I first, I last, const T& val) {
    while (first!=last && *first != val) 
        ++first;
    return first; 
}
*/

int main() {
    vector<int> v;
    v.push_back(10);
    v.push_back(123);
    v.push_back(87);

    vector<int>::iterator p = find(v.begin(), v.end(), 123);
    if (p != v.end())
        cout << "Found " << *p << endl;
    else
        cout << "Not found" << endl;

    list<string> words;
    words.push_back("Money");
    words.push_back("For");
    words.push_back("Nothing");

    list<string>::iterator q = find(words.begin(), words.end(), "Chicks");
    if (q != words.end())
        cout << "Found " << *q << endl;
    else
        cout << "Not found" << endl;

    double nums[] = {1.4, 50.1, 3.5};
    double *r = find(nums, nums + sizeof(nums)/sizeof(double), 50.1);
    if (r != nums + sizeof(nums)/sizeof(double))
        cout << "Found " << *r << endl;
    else
        cout << "Not found" << endl;
}
					

#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <string>
using namespace std;

template<typename T>
class List {
private:
    //Definition of class Node is the same as before
    class Node {
    public:
        Node(T d, Node *n = NULL, Node *p = NULL)
            : data(d), next(n), prev(p) {}

        T data;
        Node *next;
        Node *prev;
    };

public:
    class Iterator : public iterator<input_iterator_tag, T> {
    private:
        Iterator(Node* n) { current = n; }
        friend class List;
    public:
        Iterator& operator++() { 
            if (current != NULL)
                current = current->next;
            return *this;
        }

        T& operator*() {
            return current->data;
        }

        bool operator==(const Iterator& it) {
            return current == it.current;
        }

        bool operator!=(const Iterator& it) {
            return current != it.current;
        }
    private:
        Node *current;
    };

    //Definition of List members are the same as before
public:
    List();
    ~List();
    void print();
    void push_front(T x);
    void push_back(T x);
    Iterator begin() {
        return Iterator(_head);
    }
    Iterator end() {
        return Iterator(NULL);
    }
private:
    Node* _head;
    Node* _last;
};

template<typename T>
List<T>::List() {
    _head = NULL;
    _last = NULL;
}

template<typename T>
void List<T>::print() {
    for (Node* p = _head; p != NULL; p = p->next) {
        cout << p->data << ' ';
    }
}

template<typename T>
void List<T>::push_front(T x) {
    Node *new_node = new Node(x);
    new_node->next = _head;
    if (_head != NULL)
        _head->prev = new_node;
    _head = new_node;
    if (_last == NULL)
        _last = new_node;
}

template<typename T>
void List<T>::push_back(T x) {
    if (_head == NULL)
        push_front(x);
    else {
        Node *new_node = new Node(x);
        new_node->prev = _last;
        _last->next = new_node;
        _last = new_node;
    }
}

template<typename T>
List<T>::~List() {
    Node *p = _head;
    while (p != NULL) {
        Node *q = p;
        p = p->next;
        delete q;
    }
    _head = NULL;
}

int main() {
    List<int> l;
    
    l.push_back(86);
    l.push_front(43);
    l.push_front(12);
    
    cout << accumulate(l.begin(), l.end(), 0) << endl;

    List<int>::Iterator it = find(l.begin(), l.end(), 43);
    if (it != l.end()) {
        cout << "found\n";
        *it = 56;
    } else
        cout << "not found\n";

    vector<string> v;
    v.push_back("gholi");
    v.push_back("aroosi");
    v.push_back("naraft!");

    cout << accumulate(v.begin(), v.end(), string("")) << endl;
    
    double dd[3] = {1.2, 3.4, 67485.2};
    cout << accumulate(dd, dd + 3, 0.0) << endl;
}
					

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

/*
template<class In, class Pred>
In find_if(In first, In last, Pred pred) {
    while (first!=last && !pred(*first)) 
        ++first;
    return first; 
}
*/

bool odd(int x) { return x % 2; }

class OddSelector {
public:
    bool operator()(int x) { return x % 2; }
};

int main() {
    vector<int> v;
    v.push_back(10);
    v.push_back(39);
    v.push_back(42);

    vector<int>::iterator it = find_if(v.begin(), v.end(), odd);
    cout << *it << endl;

    vector<int>::iterator it2 = find_if(v.begin(), v.end(), OddSelector());
    cout << *it2 << endl;
}
					

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

/*
template<class In, class Pred>
In find_if(In first, In last, Pred pred) {
    while (first!=last && !pred(*first)) 
        ++first;
    return first; 
}
*/

class student {
public:
    student(string n, double d) : name(n), grade(d) {}
    string get_name() const { return name; }
    double get_grade() const { return grade; }
private:
    string name;
    double grade;
};

class GradeBelow {
public:
    GradeBelow(double c) : cutoff(c) {}
    bool operator()(const student& s) {
        return s.get_grade() < cutoff;
    }
private:
    double cutoff;
};

int main() {
    vector<student> v;
    v.push_back(student("Moez", 8.0));
    v.push_back(student("Gholam", 17.3));
    v.push_back(student("Ghamar", 4.5));

    vector<student>::iterator it;
    it = find_if(v.begin(), v.end(), GradeBelow(10));
    cout << it->get_name() << endl;
    
    it = find_if(v.begin(), v.end(), GradeBelow(5));
    cout << it->get_name() << endl;
}