ОБЪЕКТНО-
ОРИЕНТИРОВАННОЕ
ПРОГРАММИРОВАНИЕ
Лекция № 2 / 6
08.10.2019 г.
NEW & DELETE
1. Key-word new, delete.
2. operator new, delete.
NEW & DELETE
1. Key-word new, delete.
2. operator new, delete.
The new-expression attempts to create an object of the type-id
or new-type-id to which it is applied.
void* operator new(std::size_t size) throw(std::bad_alloc);
Effects: The allocation function called by a new-expression to
allocate size bytes of storage suitably aligned to represent any
object of that size ...
NEW & DELETE
// Global functions
void* operator new(size_t);
void* operator new[](size_t);
void operator delete(void *);
void operator delete[](void *);
PLACEMENT NEW
class Arena {
public:
Arena(int x) {};
~Arena() {};
// ...
};
const int n = 100;
Arena* placementMem = static_cast<Arena*>(operator new[] (n* sizeof(Arena)));
for(int i = 0; i < n; ++i){
new (placementMem + i) Arena(rand());
}
for(int i = 0; i < n; ++i){
placementMem[i].~A();
}
operator delete[] (placementMem);
VARIADIC TEMPLATES EMULATION
UNTIL С++11
struct unused;
template<typename T1 = unused, typename T2 = unused,
/*up to*/ typename TN = unused> class tuple;
typedef tuple<char, short, int, long, long long>
integral_types;
// N-5 unused parameters
VARIADIC TEMPLATES EMULATION
UNTIL С++11
// Default template parameters are not allowed in any
// function template declaration or definition until C++11
tuple<> make_tuple()
{ return tuple<>(); }
template<typename T1>
tuple<T1> make_tuple(const T1& t1)
{ return tuple<T1>(t1); }
template<typename T1, typename T2>
tuple<T1, T2> make_tuple(const T1& t1, const T2& t2)
{ return tuple<T1, T2>(t1, t2); }
DISADVANTAGES
• Code duplication.
• Longtype names in error messages (compilers usually print
default arguments).
• Fixed upper limit on the number of arguments.
VARIADIC TEMPLATES
template <typename... Arguments>
class VariadicTemplate;
VariadicTemplate<double, float> instance; // Ok
VariadicTemplate<bool, std::vector<int>, char> instance; // Ok
VariadicTemplate<> instance; // Ok
VARIADIC TEMPLATES
template <typename T, typename... Arguments>
class VariadicTemplate;
VariadicTemplate<double, float> instance; // Ok
VariadicTemplate<bool, std::vector<int>, char> instance; // Ok
VariadicTemplate<> instance; // Error
VARIADIC TEMPLATES
template <typename T = int, typename... Arguments>
class VariadicTemplate;
VariadicTemplate<double, float> instance; // Ok
VariadicTemplate<bool, std::vector<int>, char> instance; // Ok
VariadicTemplate<> instance; // Ok
ELLIPSIS (...)
int printf (const char* format, ...);
#define VARIADIC_MACRO(...)
try{
// Try block.
}
catch(...){ template parameter pack
// Catch block.
} function parameter pack
template <typename... Arguments>
void function(Arguments... params);
TEMPLATE PARAMETER PACK
//A type template parameter pack with an optional name
//"Arguments"
template <typename... Arguments>
class VariadicTemplate;
//A non-type template parameter pack with an optional name
//"Dimensions"
template <typename T, unsigned... Dimensions>
class MultiArray;
using TransformMatrix = MultiArray<double, 3, 3>;
//A template template parameter pack with an optional name
//"Containers", С++17
template <typename T,
template <typename, typename> typename... Containers>>
void testContainers();
TEMPLATE PARAMETER PACK
• Primary class templates, variable templates, and alias templates
may have at most one template parameter pack and, if
present, the template parameter pack must be the last
template parameter.
• Multiple
template parameter packs are permitted for function
templates.
• Declarationsof partial specializations of class and variable
templates can have multiple parameter packs.
TEMPLATE PARAMETER PACK
//???
template <typename... Types, typename Last>
class LastType;
//???
template <typename... Types, typename T>
void test(T value);
template <typename...> struct TypeList{};
//Primary class template
template <typename X, typename Y> struct Zip{};
//???
template <typename... Xs, typename... Ys>
struct Zip<TypeList<Xs...>, TypeList<Ys...>>{};
TEMPLATE PARAMETER PACK
//Error. Template parameter pack is not the last template
//parameter.
template <typename... Types, typename Last>
class LastType;
//Ok. Template parameter pack is followed by a deducible
//template.
template <typename... Types, typename T>
void test(T value);
template <typename...> struct TypeList{};
//Primary class template.
template <typename X, typename Y> struct Zip{};
//Ok. Partial specialization uses deduction to determine
//the Xs and Ys substitutions.
template <typename... Xs, typename... Ys>
struct Zip<TypeList<Xs...>, TypeList<Ys...>>{};
PACK EXPANSION
A pack expansion is a construct that expands an argument pack
into separate arguments..
An intuitive way to understand pack expansions is to think of
them in terms of a syntactic expansion, where template
parameter packs are replaced with exactly the right number of
(non-pack) template parameters and pack expansions are
written out as separate arguments, once for each of the non-
pack template parameters.
PACK EXPANSION
template <typename... Types>
class MyTuple : public Tuple<Types...> { //Code };
Syntactic expansion
for 2 parameters
template <typename T1, typename T2>
class MyTuple : public Tuple<T1, T2> { //Code };
Syntactic expansion
for 3 parameters
template <typename T1, typename T2, typename T3>
class MyTuple : public Tuple<T1, T2, T3> { //Code };
PACK EXPANSION
Each pack expansion has a pattern, which is the type or
expression that will be repeated for each argument in the
argument pack and typically comes before the ellipsis that
denotes the pack expansion.
template <typename... Types>
class PtrTuple : public Tuple<Types*...> { //Code };
Syntactic expansion
for 2 parameters
template <typename T1, typename T2>
class PtrTuple : public Tuple<T1*, T2*> { //Code };
WHERE CAN PACK EXPANSIONS OCCUR?
template <typename... Types>
struct Example : Types... //In the list of base classes.
{
typedef std::tuple<const Types...> Tuple_t; //In the template
//parameter list of a class
Example(): Types()... //In the list of base class initializers in a
{} //constructor.
void run(const Types&... args){ //In a list of call arguments
//Operator sizeof...()
std::cout << sizeof...(args) << std::endl;
std::cout << sizeof...(Types) << std::endl;
}
};
template <int... Values>
void square(){
auto list = {(Values*Values)...}; //In a list of initializers
for(auto& item: list){
std::cout << item << " ";
}
}
VARIADIC TEMPLATE EXAMPLE
//Non-template function
void print()
{
}
template <typename T, typename... Types>
void print(T firstArg, Types... args)
{
std::cout << firstArg << std::endl; //Print first argument
print(args...); //Call "print" for another arguments
}
//Example
std::string s("world");
print(7.5, "hello", s);
CALL STACK
//T - double; firstArg = 7.5;
//Types... - char const*, std::string; args = "hello", "world";
print<double, char const*, std::string>(7.5, "hello", s);
//T - char const*; firstArg = "hello";
//Types... - std::string; args = "world";
print<char const*, std::string>("hello", s);
//T - std::string; firstArg = "world"; //Call non-template
//Types... - empty; args = empty; //function
print<std::string>(s); print();
VARIADIC AND NON-VARIADIC
TEMPLATES OVERLOADING
template <typename T>
void print(T arg)
{
std::cout << arg << std::endl;
}
template <typename T, typename... Types>
void print(T firstArg, Types... args)
{
print(firstArg); //Call print() for first argument
print(args...); //Call print() for another arguments
}
//Example
std::string s("world");
print(7.5, "hello", s);
CALL STACK
//variadic template function
print<double, char const*, std::string>(7.5, "hello", s);
//template function
print<double>(7.5);
//variadic template function
print<char const*, std::string>("hello", s);
//template function
print<char const*>("hello");
//template function
print<std::string>(s);
COUNTING ARGUMENTS
template <typename... Args> struct count;
template <>
struct count<>{
static const int value = 0;
};
template <typename T, typename... Args>
struct count<T, Args...>{
static const int value = 1 + count<Args...>::value;
};
template <typename... Elements>
class tuple{
static const int length = count<Elements...>::value;
};
EXPANSION WITHOUT RECURSION
template <int... Nums> template <typename... Args>
int nonRecursiveSum1(){ int ignore(Args&&...){}
auto list = { Nums... };
int sum{}; template <int... Nums>
int nonRecursiveSum2(){
for(auto& num : list){ int sum{};
sum += num; ignore(sum += Nums...);
}
return sum;
return sum; }
}
FOLD EXPRESSIONS C++17
//fold expression
template <typename... T>
auto foldSum(T... s){
return (0 + ... + s);
}
//Possible fold expressions (since с С++17)
(... op pack) -> (((pack1 op pack2) op pack3)... op packN)
(pack op ...) -> (pack1 op (... op (packN-1 op packN)))
(init op ... op pack) -> (((init op pack1) op pack2)... op packN)
(pack op ... op init) -> (pack1 op (... op (packN op init)))
FOLD EXPRESSIONS C++17
template <typename... Types>
void print(Types... args)
{
(std::cout << ... << args) << std::endl;
}
//Example
std::string s("world");
print(7.5, "hello", s);
FOLD EXPRESSIONS C++17
template <typename T>
class AddSpace{
const T& ref;
public:
AddSpace(const T& ref): ref(ref){}
friend std::ostream& operator<< (std::ostream& os, AddSpace<T> s){
return os << s.ref << ' ';
}
}
template <typename... Types>
void print(Types... args)
{
(std::cout << ... << AddSpace(args)) << std::endl;
}
TUPLE
template<typename... Args>
struct tuple;
template<typename Head, typename... Tail>
struct tuple<Head, Tail...> : tuple<Tail...>
{
tuple(Head h, Tail... tail)
: tuple<Tail...>(tail...), head_(h)
{}
typedef tuple<Tail...> base_type;
typedef Head value_type;
base_type& base = static_cast<base_type&>(*this);
Head head_;
};
tuple<int, double, char> t(1, 2.0, '3');
template<> std::cout << t.head_ <<
struct tuple<>
t.base.head_ << std::endl;
{};
TUPLE
template<int I, typename Head, typename... Args>
struct getter
{
typedef typename getter<I - 1, Args...>::return_type return_type;
static return_type get(tuple<Head, Args...> t)
{
return getter<I - 1, Args...>::get(t);
}
};
template<typename Head, typename... Args>
struct getter<0, Head, Args...>
{
typedef typename tuple<Head, Args...>::value_type return_type;
static return_type get(tuple<Head, Args...> t)
{
return t.head_;
}
};
TUPLE
template<int I, typename Head, typename... Args>
struct getter
{
static decltype(auto) get(tuple<Head, Args...> t)
{
return getter<I - 1, Args...>::get(t);
}
};
template<typename Head, typename... Args>
struct getter<0, Head, Args...>
{
static decltype(auto) get(tuple<Head, Args...> t)
{
return t.head_;
}
};
TUPLE
template<int I, typename Head, typename... Args>
decltype(auto) get(tuple<Head, Args...> t)
{
return getter<I, Head, Args...>::get(t);
}
tuple<int, double, char> t(1, 2.0, '3');
std::cout << get<0>(t) << " " << get<1>(t) << " " <<
get<2>(t) << std::endl;
