Categorization | Structural update ..

Author: dimkatsi91

deques/deque_ex1.cpp

@@ -0,0 +1,38 @@
+#include <deque>
+#include <iostream>
+
+using namespace std;
+
+template<typename T>
+void show(const char* msg, deque<T> q)
+{
+    cout << msg << endl;
+    for(unsigned i=0; i<q.size(); i++)
+        cout << q[i] << " ";
+    cout << endl;
+}
+
+
+main()
+{
+    deque<int> dq(10);
+    for(unsigned i=0; i<dq.size(); ++i)     dq[i] = i*i;
+    show("Contents of dq: ", dq);
+
+    int sum = 0;
+    for(unsigned i=0;i<dq.size();++i)   sum += dq[i];
+    double avg = sum / dq.size();
+    cout << "The average of dq = " << avg << endl;
+
+    for(unsigned i=0;i<dq.size();++i)   dq.pop_back();
+    show("After poping dq contents are: ", dq);
+
+    cout << "\n" << *dq.begin() << "\t" << *(dq.end()-1) << endl << endl;
+    cout << "\n" << *dq.rbegin() << "\t" << *(dq.rend()-1) << endl << endl;
+
+    cout << "\n\n";
+    deque<int> dq2(dq.begin()+2, dq.end()-2);       // Keep only element 4
+    dq2.push_front(3);                              // add 3 in the beginning
+    dq2.push_back(5);                               // add 5 in the end 
+    show("Contents of dq2 are: ", dq2);
+}

deques/stack.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include "stack.h"
+
+using namespace std;
+
+int main()
+{
+    Stack< double > doubleStack;
+    const size_t doubleStackSize = 5;
+    double doubleValue = 1.1;
+
+    cout << "Pushing elements onto doubleStack\n";
+
+    for(size_t i=0; i<doubleStackSize; ++i)
+    {
+        doubleStack.push(doubleValue);
+        cout << doubleValue << " ";
+        doubleValue += 1.1;
+    }
+
+    cout << "\n\nPoping elements from doubleStack\n";
+    while( !doubleStack.isEmpty() ) {
+        cout << doubleStack.top() << " ";
+        doubleStack.pop();
+    }
+    cout << "\nStack is now empty. Can not pop.\n\n";
+
+    cout << "\n\nINTEGERS STACK NOW\n\n";
+    Stack< int > intStack;
+    const size_t intStackSize = 10;
+    int intValue = 1;
+
+    cout << "Pushing elements onto intStack\n";
+    for(size_t i =0; i<intStackSize; ++i) {
+        intStack.push( intValue );
+        cout << intValue++ << " ";
+    }
+
+    cout << "\n\nPoping elements from intStack\n";
+    while( !intStack.isEmpty() ) {
+        cout << intStack.top() << " ";
+        intStack.pop();
+    }
+    cout << "\nIntStack is now empty. Cannot pop anymore...\n";
+
+    return 0;
+}

deques/stack.h

@@ -0,0 +1,40 @@
+#ifndef stack_h
+#define stack_h
+
+#include <deque>
+
+template<typename T>
+class Stack {
+private:
+    std::deque< T > stack;
+public:
+    // Return the up element of the stack
+    T& top() {
+        return stack.front();
+    }
+    // Add an element to the stack
+    void push( const T &pushValue ) {
+        stack.push_front( pushValue );
+    }
+    // Remove an element from the stack
+    void pop() {
+        stack.pop_front();
+    }
+    // Check if the stack is empty
+    bool isEmpty() const {
+        return stack.empty();
+    }
+    // Return the size of the stack
+    size_t size() const {
+        return stack.size();
+    }
+};
+
+/*
+template<c class T >
+inline void Stack< T >:: pop()
+{
+    return stack.pop_front();
+}
+*/
+#endif

io/append_to_file.cpp

@@ -0,0 +1,91 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+
+using namespace std;
+
+#define FAIL 1
+#define SUCCESS 0
+#define FILENAME "/home/diman91/Documents/Cpp-STL-Examples/Firewall.txt"
+
+bool cat_file(const char* filename)
+{
+  char ch;
+
+  ifstream in_file;
+  in_file.open(filename);
+
+  if(!in_file.is_open()) {
+    cout << "File was not opened! ERROR! Aborting...\n";
+    return FAIL;
+  }
+
+  do {
+    in_file.get(ch);
+
+    if(!in_file.eof() && ( in_file.fail() || in_file.bad() )) {
+      cout << "ERROR! Aborting ...";
+      in_file.close();
+      return FAIL;
+    }
+
+    if(!in_file.eof())
+      cout << ch;
+  } while(!in_file.eof());
+
+  in_file.clear();    // needed for eof and fail
+
+  in_file.close();
+
+  if(!in_file.good()){
+    cout << "ERROR! ... in closing file ... Aborting ...";
+    return FAIL;
+  }
+
+  return SUCCESS;
+}
+
+
+// Function to write contents to a file
+bool write_file(const char* filename, const char* content)
+{
+  ofstream out_file;
+  out_file.open(filename, ios::out | ios::app);
+
+  if(!out_file.is_open()) {
+    cout << "File was not opened! ERROR! Aborting...\n";
+    return FAIL;
+  }
+
+  out_file << content << endl;
+
+  out_file.close();
+
+  if(!out_file.good()){
+      cout << "ERROR! Aborting ...";
+      return FAIL;
+  }
+
+  return SUCCESS;
+}
+
+
+int main()
+{
+  vector<const char*> commands = {"iptables -A INPUT -p tcp -s 192.168.16.0/16 --dport 24 -j ACCEPT",
+                                  "iptables -A INPUT -p tcp -s 192.168.17.0/16 --dport 24 -j ACCEPT",
+                                  "iptables -A INPUT -p tcp -s 192.168.16.0/16 --dport 21 -j ACCEPT",
+                                  "iptables -A INPUT -p tcp -s 192.168.17.0/16 --dport 21 -j ACCEPT",
+                                  "iptables -A INPUT -j DROP"
+                                };
+  vector<const char*>::iterator itr = commands.begin();
+  while(itr != commands.end()) {
+    //cout << *itr << endl;
+    write_file(FILENAME, *itr);
+    itr++;
+  }
+
+  cat_file(FILENAME);
+
+  return 0;
+}

lambdas/lambda1.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>  // for_each
+
+using namespace std;
+
+auto test = []( const vector<int>& vec ) {
+  for(auto val : vec)
+    cout << val << " ";
+  cout << endl;
+};
+
+auto AVG = [](const vector<int>& vec) {
+  int sum_=0;
+  for_each( vec.begin(), vec.end(),
+            [&sum_](int elem) { sum_+=elem; }
+          );
+  cout << "AVG = " << sum_/vec.size() << endl;
+};
+
+int main()
+{
+  vector<int> nums{};
+  for(size_t i=100; i>=50; i-=10)   nums.push_back( i );
+  test(nums);
+
+  AVG(nums);
+
+  return 0;
+}

lists/lst.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include <list>
+#include <algorithm>  // copy
+#include <iterator> // ostream_iterator
+
+using namespace std;
+
+template<class T>
+class LIST {
+  template<typename TT>
+  friend ostream& operator<<( ostream& , LIST<TT>& );
+private:
+  list<T> lst;
+  T limit;
+public:
+  LIST(T lm) : limit(lm) {}
+  ~LIST() {
+    cout << "Poping elements...\n";
+    while( !lst.empty() ) {
+      cout << lst.back() << " ";
+      lst.pop_back();
+    }
+    cout << "\n";
+  }
+  void push() {
+    cout << "Pushing elements...\n";
+    for(T i=0; i<limit; i++)
+      lst.push_back(i);
+  }
+};
+
+template<typename TT>
+ostream& operator<<( ostream& out, LIST<TT> &listRef ) {
+  ostream_iterator<TT> output( out, " " );
+  copy( listRef.lst.begin(), listRef.lst.end(), output );
+  out << "\n";
+  return out;
+}
+
+main() {
+
+  LIST<int> LI(21);
+  LI.push();
+  cout << LI;
+
+  return 0;
+}

maps/map1.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <map>
+#include <string>
+
+using namespace std;
+
+class Catalogue {
+private:
+  string name_;
+  map<string, size_t> addr_;
+  string tel;
+public:
+  Catalogue(const string& name, const string& addr_a, const size_t addr_nu, const string& tel_num)
+    : name_(name), tel(tel_num) {
+      addr_.insert({addr_a, addr_nu});
+    }
+  ~Catalogue() {}
+  void show(ostream& );
+};
+
+void Catalogue::show(ostream& out) {
+  map<string, size_t>::iterator itr = (this->addr_).begin();
+  out << "Name:             " << this-> name_ << endl;
+  out << "Address:          " << itr->first << " " << itr->second << endl;
+  out << "Telephone number: " << this->tel << endl;
+}
+
+
+int main()
+{
+  Catalogue cat1("Zinedin Zidan", "New York Avenue", 888, "0123456789");
+  cat1.show(cout);
+  // map test
+  return 0;
+}

maps/map_ex_1.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <string>
+#include <map>
+
+using namespace std;
+
+void show(const char* msg, map<string, int> mp)
+{
+    map<string, int>::iterator itr;
+
+    cout << msg << "\n";
+    for(itr=mp.begin();itr!=mp.end();++itr) {
+        cout << "KEY: " << itr->first << "\t->\tVALUE: " << itr->second << "\n";
+    }
+    cout << endl;
+}
+
+int main()
+{
+    map<string, int> m;
+    m.insert(pair<string, int>("Alpha", 100));
+    m.insert(pair<string, int>("Gamma", 300));
+    m.insert(pair<string, int>("Delta", 400));
+    m.insert(pair<string, int>("Beta", 200));
+
+    //
+    map<string, int> m2(m);
+
+    map<string, int>::iterator itr;
+
+    itr = m.begin();
+    cout << "FIrst key/value pair in m is: " << itr->first << ", " << itr->second << endl;
+
+    itr = m.end();
+    --itr;
+    cout << "\nThe last key/value pair in m is: " << itr->first << ", " << itr->second << "\n\n";
+
+    show("Contents of m are: ", m);
+    m.clear();
+    show("M is now empty: ", m);
+
+    m2.erase("Delta");
+    m2.erase("Alpha");
+    show("M2 after erasing two key/values is: ", m2);
+
+    m.swap(m2);
+    show("\nM2 after swap is: ", m2);
+    show("\nM after swap is: ", m);
+
+    return 0;
+}