the standard template library part 2 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
The Standard Template Library – part 2 PowerPoint Presentation
Download Presentation
The Standard Template Library – part 2

Loading in 2 Seconds...

play fullscreen
1 / 15

The Standard Template Library – part 2 - PowerPoint PPT Presentation


  • 83 Views
  • Uploaded on

The Standard Template Library – part 2. auto_ptr<>. Regular pointers may cause memory leaks void f() { SomeClass *ptr = new SomeClass; … // exception or improperly implemented early return from f() … delete ptr; // memory leak if this statement is not reached }

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

The Standard Template Library – part 2


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
auto ptr
auto_ptr<>
  • Regular pointers may cause memory leaks

void f()

{

SomeClass *ptr = new SomeClass;

// exception or improperly implemented early return from f()

delete ptr; // memory leak if this statement is not reached

}

    • The memory leak may be avoided
      • We may use exception mechanism to catch exceptions
      • We shoud delete all allocated memory in case of early return
auto ptr1
auto_ptr<>
  • auto_ptr is an object (template) that
    • Acts as an inteligent pointer
    • Owns data assigned to it
    • Manages asigned data to avoid memory leaks
      • (defined in <memory> header)

void f()

{

std::auto_ptr<SomeClass> ptr(SomeClass);

// exception or early return from f() – ok!

// no need to delete ptr; ~auto_ptr() does it for us

}

auto ptr2
auto_ptr<>
  • auto_ptr owns data assigned to it
    • Assignment from regular pointer not allowed

// std::auto_ptr<SomeClass> ptr = new SomeClass; ERROR, but there is a reset()

    • There may be only one one auto_ptr that owns specific object/variable
      • copy constructor and assignment operator move data from source auto_ptr, so they modify their arguments – unusual behaviour
      • auto_ptr should not be an element of a container (why?)
  • auto_ptr acts as an inteligent pointer
    • Overloads *(ptr) and ptr->
    • It is a pointer to single object, not to an array, container – ok.
    • Does not overload pointer arithmetic operators (++, [], etc)
    • Extra methods :
      • T* get() – returns address of the owned data (or NULL), not changing ownership
      • T* release() – returns address of the owned data (or NULL), releasing ownership
      • void reset(T * ptr=0) – assignment from regular pointer, creating ownership
auto ptr3
auto_ptr<>
  • copy constructor

std::auto_ptr<SomeClass> ptr1(SomeClass);

std::auto_ptr<SomeClass> ptr2(ptr1);

// now ptr1 is empty

  • assignment operator

std::auto_ptr<SomeClass> ptr1(SomeClass);

std::auto_ptr<SomeClass> ptr2(SomeClass);

ptr2=ptr1;

// *ptr2 (old one) gets destructed first,

// now ptr1 is empty

auto ptr4
auto_ptr<>
  • auto_ptr as argument or return value
    • Should be passed as variable, not as reference
    • This way we create sink (argument) or source (ret. val.) of data
  • const auto_ptr
    • will not allow to transfer owned data to another auto_ptr
    • will not allow to assign data owned by another auto_ptr
      • ultimately will destruct owned data
      • changing owned data still ok.
    • good for sink
  • const auto_ptr &
    • for functions operating on owned data without changing ownership
    • examples: util/autoptr1.cpp util/autoptr2.cpp
auto ptr5
auto_ptr<>
  • auto_ptr as a member variable
    • may make destructor not necessary
    • is safe even for exceptions thrown by a constructor
      • as opposed to regular pointers, since if constructor fails then destructor is not executed
    • usually requires implementing copy constructor and assignment operator
      • since default ones woud remove data from object being assigned
numeric limits
numeric_limits<>
  • numeric_limits<> is a template that defines various properties of a numerical types
  • member variables and methods should be used to determine type properties at the compile time
    • numeric_limits<int>::digits // no. of bits for integer types
    • numeric_limits<int>::max() // easy to guess
  • it is implemented as a template that has specializations for all fundamental types
special containers
Special containers
  • stack (LIFO queue, implemented using deque)
  • queue (FIFO queue, implemented using deque)
  • priority_queue
  • bitset
  • hash_set, hash_multiset, hash_map, hash_multimap

(implemented using hash table instead of binary tree)

stack
stack
  • header <stack>
  • simple LIFO queue implemented using deque
    • may be based on any container supporting: back(), push_back(), pop_back(),
    • just give 2nd template argument, eg.: stack<int, vector<int> >
  • just redirects own methods to deque methods to obtain LIFO queue
  • example: cont/stack1.cpp
  • push()
  • pop()
  • top() // get the value of topmost element // but do not remove it from stack
  • size() // get the current number of elemets
  • empty() // is it empty
  • operators: ==, !=, <, >, <=, >= // == returns 1 if size and all elements are equal
  • no more methods or operators
queue
queue
  • header <queue>
  • simple FIFO queue implemented using deque
    • may be based on any container supporting: front(), back(), push_back(), pop_front()
    • just give 2nd template argument, eg.: queue<int, list<int> >
  • just redirects own methods to deque methods to obtain FIFO queue
  • example: cont/queue1.cpp
  • push()
  • pop()
  • back() // get the value of element most recently push-ed // but do not remove it from stack
  • front() // get the value of element at the front of queue // but do not remove it from queue
  • size() // get the current number of elemets
  • empty() // is it empty
  • operators: ==, !=, <, >, <=, >= // == returns 1 if size and all elements are equal
  • no more methods or operators
priority queue
priority_queue
  • header <queue>
  • simple priority queue implemented using vector
    • may be based on any container supporting: front(), push_back(), pop_front(), oper.[]
    • just give 2nd template argument, eg.: priority_queue<int, deque<int> >
    • the 3rd argument is a sort criterion (defaults to operator< )

priority_queue<int, vector<int>, greater<int> >

  • redirects own methods to vector methods
  • example: cont/pqueue1.cpp
  • push()
  • pop()
  • top() // get the value of element of the greatest priority // but do not remove it from queue
  • size() // get the current number of elemets
  • empty() // is it empty
  • no more methods or operators (no operator ==, etc.)
bitset
bitset
  • header <bitset>
  • convinient class for handling fixed size sets of bits

bitset<20> flags;

  • performing bit stream i/o
    • example: cont/bitset1.cpp
  • also to perform integer i/o in binary format
    • example: cont/bitset2.cpp
  • no copy constructor or assignment operator
bitset1
bitset
  • bitset constructors

bitset<bits>::bitset()

bitset<bits>::bitset(unsigned long val)

bitset<bits>::bitset(const string &sc)

// no char* initialization, couple variants of string initialization

  • bitset methods and operators

size() // return size of bitset

count() // count ones

any() // 1 if at least one bit set

none() // !any()

test(size_t idx) // is the idx-th bit set

operator==(const bitset<bits>& arg)

operator!=(const bitset<bits>& arg)

bitset2
bitset
  • bitset methods and operators

set() // set all to ones

set(size_t idx, int value=1)

reset() // set all to zeroes

reset(size_t idx) // set idx-th to zeroes

flip() // negate all bits

flip(size_t idx)

bitwise operators (argument size must match): ^= |= &= ^ | & ~

bitwise shift operators (size_t argument): <<= << >>= >>

steram operators: << >>

bool operator[] (size_t idx) const // undefined behaviour if idx out of range

bitset<bits>::reference operator[] (size_t idx) // returns object of special proxy type

// with reference type we may: =(bool), =(const reference &), flip(), operator~(), bool()

to_ulong(), to_string()