1. #include <iostream>
2. #include <array>
3. #include <vector>
4. #include <memory>
5. #include <list>
6. #include <math.h>
7. class OneVertexException:public std::exception{
8. public:
9.     const char * what(){
10.         return "Edge must have minimum 2 vertices!";
11.     }
12. };
13.  
14. template<typename T, std::size_t N>
15. class Point {
16. public:
17.     template<typename ... Ts>
18.     explicit Point(Ts... ts)
19.             : data_{ts...}
20.     {
21.     }
22.  
23.     T operator[](std::size_t index) const
24.     {
25.         return data_[index];
26.     }
27.  
28. private:
29.     std::array<T, N> data_;
30. };
31.  
32. template<typename T, std::size_t N>
33. class LamanLine {
34.     std::vector<Point<T, N>> vectorOfPoints_;
35.     std::list<std::pair<Point<T, N>, Point<T, N>>> edges_;
36.  
37. public:
38.     void addPoint(Point<T, N> & newPoint) {
39.  
40.         if(vectorOfPoints_.size()>=1) {
41.             std::pair<Point<T, N>, Point<T, N>> buf;
42.             buf.first = vectorOfPoints_.back();
43.             vectorOfPoints_.push_back(newPoint);
44.             buf.second = vectorOfPoints_.back();
45.             edges_.push_back(buf);
46.         } else {
47.             vectorOfPoints_.push_back(newPoint);
48.         }
49.  
50.     }
51.     double calculateLenght(){
52.         double result=0;
53.         if(vectorOfPoints_.size()<2) throw OneVertexException();
54.         for(auto &element: edges_) result += (double)distance(element.first, element.second);
55.         return result;
56.     }
57. };
58.  
59.  
60.  
61. template<typename T, std::size_t N>
62. std::ostream& operator<<(std::ostream& os, const Point<T,N>& point)
63. {
64.     os << "<";
65.     for(std::size_t i = 0; i < N-1; ++i)
66.     {
67.         os << point[i] << ", ";
68.     }
69.     os << point[N-1] << ">";
70.  
71.     return os;
72. }
73.  
74. // uzupelnic metode !!.
75. template<typename T, std::size_t N>
76. T distance(const Point<T,N>& lhs, const Point<T,N>& rhs)
77. {
78.     T sum =0;
79.     for(size_t i=0; i<N; i++){
80.         sum += (T)pow(lhs[i]-rhs[i], 2);
81.     }
82.     auto result = (T)sqrt(sum);
83.     return result;
84. }
85.  
86. // Zadanie
87. // Nalezy stworzyc szablon klasy reprezentujacy linie lamana w N wymiarowej przestrzeni.
88. // Nalezy zaimplementowac metode dodajaca kolejne punkty do lamanej.
89. // Nalezy zaimplementowac metode obliczajaca dlugosc lamanej i pokazac jej dzialanie.
90. // Nalezy obsluzyc jeden (dowolnego rodzaju) wyjatek i pokazac w programie dzialanie mechamizmu.
91. //
92. // kompilacja i uruchomienie
93. // clear; g++ -std=c++17 nDpoints.cc; ./a.out;
94.  
95. int main()
96. {
97.     std::cout << "PROE2020L gr 101 - sprawdzian \"szablony i wyjatki\"" << std::endl;
98.     auto p1 = Point<int, 2>(3,5);
99.     auto p2 = Point<int, 2>(6,3);
100.     auto p3 = Point<int, 2>(6,8);
101.     auto l2 = LamanLine<int, 2>();
102.     l2.addPoint(p1);
103.     //l2.addPoint(p2);
104.     //l2.addPoint(p3);
105.     std::cout << p1 << p2 << std::endl;
106.     try {
107.         std::cout<< l2.calculateLenght()<<std::endl;
108.     }
109.     catch (OneVertexException & exp) {
110.         std::cout<<exp.what()<<std::endl;
111.     }
112.     return 0;
113. }
114.