Distributed Real-Time Control Systems. Lecture 16 C++ Libraries Templates

Transcription

1 Distributed Real-Time Control Systems Lecture 16 C++ Libraries Templates 1

2 C++ Libraries One of the greatest advantages of C++ is to facilitate code reuse. If code is well organized and documented into libraries, many programming problems can be addressed using already existing code. We are going to look into the following libraries: The C Standard Library: to invoke legacy C functions using a C++ syntax. The C++ Standard Library: classes, templates and functions for common and widely used operations, including strings, stream I/O and the STL (Standard Template Libraries) for data structures and associated algorithms. Boost: a third party libraries, compatible with the C++ standard libraries, with classes and functions for cross platform multi-threaded programming. 2

3 The C Standard Library This library is an adaptation of the common C library functions, that are encapsulated in the std:: namespace. The following headers are available: <cassert> <cctype> <cerrno> <cfenv> <cfloat> <cintypes> <ciso646> <climits> <clocale> <cmath> <csetjmp> <csignal> <cstdarg> <cstdbool> <cstddef> <cstdint> <cstdio> <cstdlib> <cstring> <ctgmath> <ctime> <cuchar> <cwchar> <cwctype> Example: Equivalent to #include <cstdio> #include <stdio.h>; 3

4 The C++ Standard Library Includes many useful functions and classes for dealing with: Streams and Input/Output: <ios>, <iosfwd>, <streambuf>, <istream>, <ostream> <fstream>, <iostream>, <sstream>, <iomanip> Strings: <string>, <regex> Containers: <array>, <bitset>, <deque>, <forward_list>, <list>, <map>, <queue>, <set>, <stack>, <unordered_map>, <unordered_set>, <vector> General: <algorithm>, <chrono>, <functional>, <iterator>, <memory>, <stdexcept>, <tuple>, <utility>, <random> Localization: <locale>, <codecvt> Numerics: <complex>, <numeric>, <valarray>, <random> Utility: <exception>, <new>, <typeinfo>, <limits> Multi-Threading: <thread>, <mutex>, <condition_variable>, <future>, <atomic> 4

5 Strings are objects that manage arrays of characters. Defined in standard library <string> Strings Expression string s string s {str string s {char* string s{str,i string s{str,i,l string s{num, c string s{char*,len string s {initlist String construction/initialization Effect Creates empty string s Copy constructor Initialized from literal c-string String with chars starting at position i String with at most l chars starting at index i String with numoccurences of char c Initialized by len characters of c-string String initialized by all chars in initlist #include <iostream> #include <string> int main() { string s0 { Hello ; // Hello string s1 = Hello World ; // Hello World string s2 { Hello World, 5; // Hello string s3 {s1, 6,1000; // World string s4 {s3; //copy ctor string s5 {5, H ; // HHHHH string s6 {{ m,{ e ; // me string s7, s8; cin >> s7; //from cin getline(cin, s8); //from cin 5

6 Strings Functions Some important member functions Expression Effect =, assign() assign a new value Expression max_size() Effect returns maximum potential length swap() +=, append() Append string push_back() insert() erase() pop_back() clear() resize() replace() empty() size(), length() Swap value between two strings Append character insert string or character at position erase part of the string, reducing its length erase the last character erase all contents, string becomes empty truncates or expands the string replaces characters returns whether the string is empty returns the number of characters capacity() reserve() shrink_to_fit() number off characters that can be held without reallocation reserves memory for a certain number of characters Shrink to current size [], at() access a character front(), back() substr() clear() data(), c_str() access first or last character returns a certain substring erase all contents, string becomes empty returns raw character array + concatenates strings copy() copies content to raw character array 6

7 Examples: String Appending string& operator+= ( const string& ); string& operator+= ( const char* ); string& operator+= ( char ); string& append ( const string& ); string& append ( const char* ); string& append ( const string&, size_t, size_t); string& append ( const char*, size_t ); string& append ( size_t, char ); #include <iostream> #include <string> int main () { string str; string str2="writing "; string str3="print 10 and then 5 more"; str += str2; str.append(str3,6,3); // 10 str.append("dots are cool",5); // dots str += "here: ; str.append(10,'.'); //... cout << str << endl; return 0; Output: Writing 10 dots here... and then 5 more... 7

8 String Comparison Functions int compare (const string&) const; int compare (const char*) const; int compare (size_t, size_t, const string&) const; int compare (size_t, size_t, const char*) const; int compare (size_t, size_t, const string&, size_t, size_t) const; int compare (size_t, size_t, const char*, size_t) const; Return: 0 if equal, positive if greater, negative if smaller. operator==(), operator!=(), operator<() operator<=(), operator>(), operator>=() #include <iostream> #include <string> int main () { string str1 ("green apple"); string str2 ("red apple"); if (str1.compare(str2)!= 0) cout << str1 << " is not " << str2 << "\n"; if (str1.compare(6, 5, "apple") == 0) cout << "still, " << str1 << " is an apple\n"; if (str2.compare(str2.size()-5, 5, "apple") == 0) cout << "and " << str2 << " is also an apple\n"; if (str1.compare(6,5,str2,4,5) == 0) cout << "therefore, both are apples\n"; return 0; output: green apple is not red apple still, green apple is an apple and red apple is also an apple therefore, both are apples 8

9 Streams and I/O A stream is an abstraction for a stream of data in which character sequences flow. Examples: console, keyboard, string, file, socket, serial port. <ios>, <iosfwd>, <streambuf>, <istream>, <ostream> - the base classes <fstream>, <iostream>, <sstream>, <iomanip> - the ones to include. 9

10 Special stream objects cout and cin cout : object of class ostream represents the standard output stream. It corresponds to the cstdio stream stdout. can write characters as formatted data using the stream insertion operator (std::ostream::operator<<) cin - object of class istream represents the standard input stream. corresponds to the cstdio stream stdin. can retrieve characters from cin using the stream extraction operator (std::istream::operator>>) #include <iostream> int main() { int i = 5; float f = 2.0; char a = b ; cout << "i = " << i <<, f = << f <<, a= << a << endl; #include <iostream> int main() { int i; float f; char ch; cin >> i >> f >> ch; 10

11 Formatted Output #include <iostream> int main () { //set new flags cout.flags ( ios::right ios::hex ios::showbase ); cout.width (10); cout << 100; Output: return 0; 0x64 #include <iostream> int main () { double f = ; cout.setf(0,ios::floatfield); // floatfield disabled. //fixed point for few digits, scientific otherwise cout.precision(5); cout << f << endl; cout.precision(10); cout << f << endl; cout.setf(ios::fixed, ios::floatfield); // floatfield enabled cout << f << endl; return 0; Output: ios:: flags boolalpha showbase effect when set read/write bool elements as alphabetic strings (true and false). write integral values preceded by their corresponding numeric base prefix. showpoint write floating-point values including always the decimal point. showpos write non-negative numerical values preceded by a plus sign (+). skipws skip leading whitespaces on certain input operations. unitbuf flush output after each inserting operation. write uppercase letters replacing lowercase letters in certain uppercase insertion operations. basefiekd dec read/write integral values using decimal base format. hex oct floatfield fixed read/write integral values using hexadecimal base format. read/write integral values using octal base format. write floating point values in fixed-point notation. scientific write floating-point values in scientific notation. adjustfield internal left right the output is padded to the field width by inserting fill characters at a specified internal point. the output is padded to the field width appending fill characters at the end. the output is padded to the field width by inserting fill characters at the beginning. 11

12 File I/O // Copy a file #include <fstream> int main () { char * buffer; long size; ifstream infile ("test.txt",ifstream::binary); ofstream outfile("new.txt",ofstream::binary); // get size of file infile.seekg(0,ifstream::end); size=infile.tellg(); infile.seekg(0); buffer = new char [size]; // allocate memory infile.read (buffer,size); //read infile outfile.write (buffer,size); // write to outfile delete[] buffer; // release memory outfile.close(); infile.close(); return 0; Flag ios::in ios::out ios::app ios::ate ios::trunc ios::binary Function Opens an input file. Use this as an open mode for an ofstream to prevent truncating an existing file. Opens an output file. When used for an ofstream without ios::app, ios::ate or ios::in, ios::trunc is implied. Opens an output file for appending only. Opens an existing file (either input or output) and seeks to the end. Truncates the old file if it already exists. Opens a file in binary mode. The default is text mode. 12

13 Overloading operator<< For easy object display, we would like to be able to do the following: Cube c1 {1.0,1.0; Cylinder c2 {3.0,2.1,0.9; cout << c1 << c2 << endl; The code would invoke the method operator<< of cout with references to c1 (a Cube&) and c2 (a Cylinder&). But cout does not have these method. We need to define them and declare as friends in Cube and Cylinder. class Cube : public Solid { friend ostream& operator<<(ostream& os, Cube &c); ostream& operator<< (ostream& os, Cube &c) { os << Cube with density << c._d << and side length << c._s << endl; return os; Must do the same for Cylinder! 13

14 Base class operator<< Better if we can use polymorphism and use a single operator for solid. This requires helper virtual functions to print the objects. // In solid.h class Solid { friend ostream& operator<< (ostream&, Solid &); virtual void Print(ostream &os) = 0; //helper ostream& operator<< (ostream& os, Solid &c) { Print(os); return os; // In cube.h void Cube::Print(ostream &os) { os << Cube with density << _d << and side length << _s << endl; // In cylinder.h void Cylinder::Print(ostream &os) { os << Cylinder with density << _d <<, radius << _r << and height _h << endl; //In main.cpp #include "cube.h" #include "cylinder.h" #include <iostream> main() { Cylinder c1 {1.0,2.0,3.0; Cube *c2 = new Cube {2.0,0.9; cout << c1 << endl; cout << *c2 << endl; Output: Cylinder with density 1.0, radius 2.0 and height 3.0 Cube with density 2.0 and side length

15 The non-member operator ostream<< We have just extended the C++ language! We added another operator<<() to the already existing ones. // Built in ostream& operator<< (ostream& os, int &); ostream& operator<< (ostream& os, float &); ostream& operator<< (ostream& os, double &); ostream& operator<< (ostream& os, char &); ostream& operator<< (ostream& os, long &); // User defined ostream& operator<< (ostream& os, Solid &c); 15

16 Templates Templates are functions or classes with parametrized types. Function Template template <class T> T GetMax (T a, T b) { return ( a > b? a : b ); Class Template template <class T> class MyPair { T values [2]; public: MyPair (T first, T second) { values[0]=first; values[1]=second; ; //Invocation int x,y; GetMax <int> (x,y); //or GetMax(x,y); //Invocation MyPair <int> myints (115, 36); mypair <double> myfloats (3.0, 2.18); 16

17 More About Templates A template can have more than one argument. We can dynamicallyspecify the size of data structures. Templates can have default types. Template code iscompiled on demand. Should be defined in header files. //MULTIPLE ARGUMENTS template <class K, class T> void func(k a, T b); //invoke as func <int, float>(3, 4.0) //MIX TYPE AND VALUE ARGUMENTS template <class T, int size> class Pilha {T _dados[size];; //invoke as Pilha <int,128> p; //DEFAULT ARGUMENTS template <class T=char, int N=10> class mysequence {..; //can be invoked as mysequence<> myseq; //same as mysequence<char, 10> myseq; 17

18 Smart Pointers Raw pointers are dangerous: They may hold invalid memory addresses. It is hard to manage their release. In header <memory>, are defined smart pointer object to manage the lifetime of objects in a more structured way: unique_ptr represents exclusive ownership, cannot be copied. shared_ptr represents shared ownership, has reference count. weak_ptr to break loops in circular shared structures (advanced use). 18

19 unique_ptr A unique_ptr stores a pointer and deletes the associated object when itself is destroyed. One can use scopes to manage the object s lifetime. A unique_ptr cannot be copied The contained pointer is not directly accessible to users. Can be used as a pointer via the * and -> operators. Up-casting works as usual. #include <memory> #include cube.h double f1(unique_ptr<solid> up) { return up->calcmass(); double f2(unique_ptr<solid> & up) { return up->calcmass(); int main() { //... { //scope to manage new Cube s lifetime unique_ptr<cube> upc{new Cube {1.0,2.0 ; cout << f1(upc) << endl; //error, no copies cout << f2(upc) << endl; //ok, ref is passed // the Cube dies here //... 19

20 shared_ptr Used when two pieces of code need to access some data, but none is responsible for its destruction. Reference counting: it has a counter of how many copies exist. When the last copy is destroyed, the pointer is deleted. #include <memory> #include cube.h double f1(shared_ptr<solid> p) { //p is a local copy increments ref count return p->calcmass(); //p destroyed decrements ref count int main() { //... { shared_ptr<cube>spc {new Cube{1.0,2.0 ; // or alternative form // auto spc = make_shared<cube>(1,2); cout << f1(spc) << endl; //ok, value copy //spc destroyed decrements ref count //if ref count is 0, deletes object 20

21 Containers A container holds a sequence of objects. Sequence containers provide access to sequences of elements. vector, list, forward_list, deque Container adaptors provide specialized access to underlying containers. queue, priority_queue, stack Associative containers provide associative lookup. Ordered (implemented as balanced binary trees: map, multimap, set, multiset Unordered (implemented as hash tables): unordered_map, unordered_multimap, unordered_set, unordered_multiset 21

22 vector The vector is the STL default container. Use it unless you have a good reason not so. A vector holds a pointer to an array of elements, the number of elements, and the capacity. The elements of a vector are contiguously allocated in memory. A vector may grow if space for new elements exceeds capacity. Involves reallocation, that invalidates existing pointers to elements. #include <iostream> //need std::cout #include <memory> //need std::unique_ptr #include <vector> //need std::vector #include "cube.h #include "cylinder.h constexpr int max_elems {10; int main() { using T = unique_ptr<solid>; //type alias vector < T > sv; sv.reserve(max_elems); sv.push_back( T {new Cube {1.25,1.0 ); // same as sv[0] = T new Cube{1.25,1.0; sv.push_back( T {new Cylinder {1.0,0.4,0.9 ); cout << sv[0] << endl; //ok cout << sv[1] << endl; //ok //cout << sv[2] << endl; //runtime error //sv goes out of scope, all objects released 22

23 Iterators Iterators are pointers to elements of the container, that allow traversing it forward or backwards. Traversing a vector with iterators float TotalMass(vector<unique_ptr<Solid>> &v) { float mass {0.0; for(auto p = v.cbegin(); p!= v.cend(); p++) mass += (*p)->calcmass(); return mass; range-for: implicit use of begin() and end() float TotalMass(vector<unique_ptr<Solid>> &v) { float mass {0.0; for(auto &s : v) mass += s->calcmass(); return mass; 23

24 Algorithms Algorithms are functions that operate in a range of objects in a container. Ranges are specified by iterators, so algorithms can run on any container. Algorithms in <algorithm> for_each, find, find_if, find_end, find_first_of, adjacent_find, count, count_if, equal, mismatch, search, search_n. transform, copy, copy_backward, swap, swap_ranges, iter_swap, replace, replace_if, replace_copy, replace_copy_if, fill, fill_n, generate, generate_n, remove, remove_if, remove_copy, remove_copy_if, unique, unique_copy, reverse, reverse_copy, rotate, rotate_copy, random_shuffle, partition, stable_partition. sort, stable_sort, partial_sort, partial_sort_copy, nth_element. lower_bound, upper_bound, equal_range, binary_search merge, inplace_merge, includes, set_union, set_intersection, set_difference, set_symmetric_difference push_heap, pop_heap, make_heap, sort_heap min, max, min_element, max_element lexicographical_compare, next_permutation, prev_permutation 24

25 Example: The Sort Algorithm template <class RandomAccessIterator> void sort ( RandomAccessIterator first, RandomAccessIterator last ); template <class RandomAccessIterator, class Compare> void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp ); #include <iostream> #include <algorithm> #include <vector> bool myfunction (int i,int j) { return (i<j); struct myclass { bool operator() (int i,int j) { return (i<j); myobject; int main () { int myints[] = {32,71,12,45,26,80,53,33; vector<int> myvector (myints, myints+8); // sort (myvector.begin(), myvector.begin()+4); //( ) sort (myvector.begin()+4, myvector.end(), myfunction); // ( ) sort (myvector.begin(), myvector.end(), myobject); //( ) cout << "myvector contains:"; for (auto it=myvector.begin(); it!=myvector.end(); ++it) cout << " " << *it; cout << endl; return 0; 25