Форум программистов, компьютерный форум CyberForum.ru

Layering Exception Handling. Stack destructor problem - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Наследование и перегрузка методов http://www.cyberforum.ru/cpp-beginners/thread635242.html
Здравствуйте. Пытаюсь выполнить упр. 8 из главы 11 книги Р.Лафоре "ООП в С++", соорудил такое древо классов (картинка в конце поста). Если коротко, то я пыжился сотворить стек, который сможет принимать как символы, так и веществ. числа. Ничего лучше не придумал, как наследовать два класса. Вот выжимка из реализующего кода (За извращенца прошу меня не считать - я только начал изучать С++) ...
C++ Картинка в виде двумерного массива пикселей Можно ли, засунув картинку в проект, получить её массив пикселей? Есть ли для этого какая-либо функция? Всё, что мне хочется, это взять картинку, формат которой предусматривает запись информации о пикселях последовательностями в 3 байта (без промежуточной информации) и засунуть туда лишний байт >:- E *хочу инфернальные картинки!!1* Добавлено через 3 часа 25 минут Есть идеи? ; ( http://www.cyberforum.ru/cpp-beginners/thread635226.html
C++ как исправить повреждением кучи
Всем привет. Имеется такой кусок кода, который читает в условном формате дату из реестра и сохраняет её в структуру, где есть SYSTEMTIME: TCHAR * timeT=new TCHAR;//главные виновники, из-за низ вылетает в конце кода программа TCHAR * TempTimeT=new TCHAR; len=MAX_PATH; ZeroMemory(NUMBER, 15);//очищаем и создаем имя, по которому обратимся в реестр ZeroMemory(Name, 20);...
C++ Сканирование экрана
Здравствуйте, нужна помощь новичку по winapi. Нужно сделать сканирование выбранной области экрана и запись результата в двумерный массив, где каждая ячейка это цвет в RGB. Делал через GetPixel, но это ужасно медленно. Читал про BitBlt но, к сожалению, не понял, как потом его в RGB переводить. Помогите пожалуйста, желательно с примером кодом. Спасибо. Добавлено через 1 час 3 минуты Уточню....
C++ Площадь многоугольника http://www.cyberforum.ru/cpp-beginners/thread635195.html
Необходимо вычислить площади двух многоугольников(ну а в дальнейшем проверить, лежит ли один из них в другом, пока мне это не надо) по известным вершинам. У меня получилось вот это."Это" не работает.Где ошибки? Заранее спасибо:) #include<iostream> #include<cstdlib> #include<cmath> using namespace std; float Ploshad(float x,float y, const int n); int main(){ int i,n1,n2; ...
C++ приоритет. странно привет всем прогерам С++ =) есть такой вопрос. Вроде ни чего сложного, но компилятор компилит это дело не так как ожидается. Есть такое предложение. IN = *block++ << 8; если указатель block ссылается на начало массива M M = {1,2,3,4,5,6,7,8,9,10}; То по таблице приоритетов сначала выполнится ++ затем * после << и только в конце будет =. В IN должно оказаться число 512:ireful:, НОоо... подробнее

Показать сообщение отдельно
Leeto
 Аватар для Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1
09.08.2012, 22:16     Layering Exception Handling. Stack destructor problem
Допустим есть проект

Array_HPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//                                                      
//                                                  (---.Array_hpp---)
//
#ifndef Array_HPP   // Preprocessor gates
#define Array_HPP
 
    #include <sstream>
    #include <iostream>
    #include <string>       // need also for ArrayException.hpp
    #include "ArrayException.hpp"
 
 
    template <class T>  //Remove the "=double" default parameter.
    class Array
        {
    
            protected:              // Declaration of private data members 
             unsigned int m_size;
             
              T*           m_data;          //m_data should be a pointer, since you want to allocate data to it
 
            public:                 // Public declaration of data members (in given example haven't ) and member functions 
                static int m_size_default;
                unsigned int array_stack_index; 
                //----------- Declaration of Constructors -----------//
              Array();                                  // Default constructor
              Array(const unsigned int new_size);       // Constructor 
              Array( Array<T>& ObjArray);           // Copy constructor
              ~Array();                                 // Destructor
 
               //----------- Declaration of Modificator(s) member functions -----------//
              void SetElement(const T& ObjType,  unsigned int index);
              static void DefaultSize( int newSize) ;
 
              //----------- Declaration of  Accessors member functions -----------//
              T& GetElement(const unsigned int index) ;
              static int  DefaultSize() ;
              unsigned int Size() const;
              unsigned int ArrayCurrentIndex();
              
 
              //----------- Declaration of Operators Overloading the class's members -----------//
              Array<T>& operator    =   (const Array& ObjArray);                //Const correctness here.
              const T& operator  [] (unsigned int index) const;
              T& operator       []  (unsigned int index);           
        };
 
    #ifndef Array_cpp // Must be the same name as in source file #define
 
        #include "Array.cpp"
 
    #endif //#ifndef Array_cpp is CLOSED
 
#endif //  #ifndef Array_HPP is CLOSED


ArrayException_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//                                                      
//                                                  (---.ArrayException_hpp---)
//
#ifndef ArrayException_HPP  // Preprocessor gates
#define ArrayException_HPP
 
 
 
 
    class ArrayException 
    {
    protected: 
 
    public : 
        ArrayException () {};
        virtual std::string GetMessage() const = 0;
    };  
 
    class OutOfBoundsException : public ArrayException
    {
    private : 
             int m_index;
    public : 
        OutOfBoundsException();
        OutOfBoundsException( int  current_index) : m_index( current_index) 
        {
        
        } 
        std::string GetMessage() const
        
        {
            
            
             
        std::ostringstream os;                          // std::stringstream object
                    os  << "\nEXCEPTION HANDLING ERROR: "
                        << "the given element " 
                        << "with index : " 
                        << m_index 
                        << " is out of bounds\n "   ;
                    return os.str();    
        }
 
    };
 
#endif // ArrayException_HPP


Point_HPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
//                                                      
//                                                  (---.Point_hpp---)
//  
#ifndef Point_HPP // Preprocessor gates
#define Point_HPP
 
// Lib(s)
    #include <string>
    #include <iostream>
    #include <sstream>
    #include <cmath>
 
    class Point 
        {   
            private:        // Declaration of private data members 
            double x;       // X coordinate
            double y;       // Y coordinate
 
            public: // Public declaration of data members (in given example haven't ) and member functions 
 
 
                //----------- Declaration of Constructors -----------//
            Point();                                                // Default constructor
            Point(const double newX ,const double newY) ;           // Constructor 
            explicit Point(const double value );                    // Second Constructor 
            Point (const Point& ObjectOfClassPoint);                // Copy constructor
            ~Point();                                               // Destructor
 
 
            //----------- Declaration of  Accessors member functions -----------//
            std::string ToString() const;    
            double X() const;                   
            double Y() const;   
            ///*virtual*/ void Draw() const { std::cout << "This's  Point from Draw()\n"; }
 
 
            //----------- Declaration and  of and Implementaion of setters member functions -----------//
            void X(const double newX) {x = newX;};  // The x-coordinate
            void Y(const double newY) {y = newY;};  // The y-coordinate
 
 
            //----------- Declaration of Calculators (additional functionality) member functions -----------//
            double Distance() const;
            double Distance(  const Point  & ObjPoint ) const;
 
 
            //----------- Declaration of Operators Overloading the class's members -----------//
            Point  operator -  () const;                                    // Negate the coordinates.
            Point  operator *  (double factor) const;                       // Scale the coordinates.
            Point  operator +  (const Point& ObjPoint) const;               // Add coordinates.
            bool   operator == (const Point& ObjPoint) const;               // Equally compare operator.
            Point& operator =  (const Point& ObjPoint);                 // Assignment operator.
            Point& operator *= (double factor );                        // Scale the coordinates & assign.
            Point& operator += (const Point& ObjPoint);
            Point& operator -= (const Point& ObjPoint);
 
 
            //----------- Declaration of Global Ostream << Operator  -----------//
            friend std::ostream& operator << (std::ostream& out,const Point & ObjPoint); 
    
        };
 
    //----------- Implementaion (inline) of getters member functions -----------//
    // Given functions should be const because we not willing 
    // modify contained variables when we call those fucntions in any case
    inline  double Point::X() const {return x;};                    
    inline  double Point::Y() const {return y;};    
 
 
#endif // Point_HPP


Stack_hpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//                                                      
//                                                  (---.Stack_hpp---)
//  
#ifndef STACK_HPP   // Preprocessor gates
#define STACK_HPP
 
    #include    "Array.hpp"
 
    template<class T>
    class Stack
        {
            private:
 
                unsigned int m_current;
 
            public:
                
                Array<T>* m_array; // in assignment only m_current private data member  
    
                //----------- Declaration of Constructors -----------//
                Stack();                            // Default (Nullary ) Construcotr
                Stack(int size);                    // Non-nullary Constructor 
                ~Stack();                           // Destructor
    
                //----------- Declaration of  Accessors member functions -----------//
                int StackCurrentIndex() const;
 
                //----------- Declaration of Setter(s) and Getter(s) member functions -----------//
                void Push(const T& element) const;          // Add a new element to the array
                T Pop() const;                              // Remove the last element of the array
                
                //----------- Declaration of Operators Overloading the class's members -----------//
                Stack<T>& operator = (const Stack<T>& ObjStack);        //assignment operator
                
        };
 
    #ifndef STACK_CPP 
 
        #include"Stack.cpp"
 
    #endif // STACK_CPP is CLOSED
 
#endif // // STACK_HPP is CLOSED


StackException_HPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//                                                      
//                                                  (---.StackException_HPP---)
//  
#ifndef StackException_HPP  // Preprocessor gates
#define StackException_HPP
 
    #include <iostream>
 
    class StackException 
        {
        public : 
 
            //----------- Declaration and  of and Implementaion of Constructor(s) of ABC  -----------//
            StackException() {};
        };
 
    class StackFullException : public StackException
        {
        public:
            
            //----------- Declaration and  of and Implementaion of Constructor(s) -----------//
            StackFullException()                                 //Constructor
    
                {
                    std::cout << "\n Stack is full " << std::endl;
                };
            virtual ~StackFullException() {};
        };
 
    class StackEmptyException : public StackException
        {
        public:
 
            //----------- Declaration and  of and Implementaion of Constructor(s) -----------//
            StackEmptyException()   
 
                {   //Constructor
                     std::cout << "\n Stack is Empty " << std::endl;
                };
            virtual ~StackEmptyException() {};
 
        };  
#endif // StackException_HPP


Array_CPP
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
//                                                      
//                                                  (---.Array_CPP---)
//  
    #ifndef Array_CPP   // Preprocessor gates
    #define Array_CPP
 
        #include "Array.hpp"
        #include "StackException.hpp"
        
 
        template <class T>
        int Array<T>::m_size_default = 10;
 
                    //----------- Implementation of Constructors -----------//
        template <class T>
        Array<T>::Array() :  m_size(m_size_default), m_data(new T[m_size]), array_stack_index(0)                                    
            {
            //  std::cout << "Array Default Constructor was called " ;
            }
 
        template <class T>
        Array<T>::Array(const unsigned int new_size) : m_size(new_size), m_data(new T[new_size]), array_stack_index(0)        
            {    //specified by the size input argument                 
            //  std::cout << "Array Constructor was called "; 
            }
 
        template <class T>
        Array<T>::Array( Array& ObjArray)
            {
                 // std::cout << "Array copy Constructor "; 
                m_size    =    ObjArray.m_size;         // shallow copy - this is not dynamic alloc
                array_stack_index = ObjArray.array_stack_index;
                if (ObjArray.m_data)                    // if not zeros then there is a ref. - Deep copy needed
                    {
                        m_data = new T[ObjArray.m_size];
                        for (unsigned int i = 0; i <   ObjArray.m_size; i++)
                        m_data[i]    =    ObjArray.m_data[i];
                    }
                else
                m_data = 0;                             //NULL
            }
 
        template <class T>
        Array<T>::~Array()
            {
                std::cout << "Array Destructor was called\n" ;
                delete [] m_data;
            }
 
        //----------- Implementaion of Modificator(s) member(s) function -----------//
        template <class T> 
        void Array<T>::SetElement(const T& ObjType, unsigned int index)
            {
                array_stack_index = index; 
                    std::cout << "Set Element[" << index << "]<-  "; 
                    if (array_stack_index >= m_size || array_stack_index < 0 )
                        {   
                            try 
                                {
                                    //std::cout << " Data wasn't setted"; 
                                    throw OutOfBoundsException(array_stack_index--);
                                }
                                catch(OutOfBoundsException) 
                                    {
                                      throw StackFullException();
                                    }
                        }
 
 
                    std::cout << ObjType << "\n"; 
                    m_data[array_stack_index] = ObjType;
            }
 
        template <typename T>
        void Array<T>::DefaultSize( int newSize) 
            { 
                m_size_default = newSize; 
            }
 
        //----------- Implementation of Accessor(s) member functions -----------//
        template <class T> 
        T& Array<T>::GetElement(const unsigned int index) 
            {
                array_stack_index = index; 
                //std::cout << "GetElement[" << index <<"] ->" ;
                    if (array_stack_index >= m_size || array_stack_index < 0)
                        {       
                            try {
                            std::cout << " Data wasn't getted"; 
                            throw OutOfBoundsException(array_stack_index++);
                                }
                                catch(OutOfBoundsException)
                                    {
                                        throw   StackEmptyException();
                                    }
 
                        }
 
                return m_data[array_stack_index];
            }
 
        template <typename T>
        int Array<T>::DefaultSize() 
            { 
                return m_size_default;
            }
 
        template<class T>
        unsigned int Array<T>::Size() const
        {
            
            return this->m_size; 
        }
 
        template<class T>
        unsigned int  Array<T>::ArrayCurrentIndex()
            {
                return this->array_stack_index; 
            }
 
        //----------- Implementation of Operators Overloading the class's member -----------//
 
        template <class T>
        Array<T>& Array<T>::operator = (const Array& ObjArray)
            {
             // std::cout << " Array Assignment operator\n";
            if (this == &ObjArray)
                {
                    //std::cout << "Same Array \n"; 
                    return *this;
                }
 
            delete [] m_data;
            // std::cout << "Deleted m_data array\n";
 
            m_size = ObjArray.m_size;       // shallow copy - this is not dynamic alloc
 
            if (ObjArray.m_data)            // if not zeros then there is a ref.
                    {
                        // std::cout <<"im here\n"; 
 
                        m_data = new T[ObjArray.m_size];        // create a new pointee.
 
                        for (unsigned int i = 0; i <    ObjArray.m_size; i++)
                        m_data[i]    =    ObjArray.m_data[i];   //copy the points from/to array
                    }
            else
                m_data = 0;  //NULL
 
            return *this;
            }
 
        template <class T> 
        T& Array<T>::operator [] (unsigned int index) 
            {
                //std::cout << "Array [] operator" << std::endl;
                array_stack_index = index; 
                if (array_stack_index >= this->m_size)
                        { 
                            throw OutOfBoundsException(index);
                        }
                return m_data[index];
            }
 
        template <class T> 
        const T& Array<T>::operator [] (unsigned int index) const
        {   
            array_stack_index = index; 
            //std::cout << "const Array [] operator" << std::endl;
            if (array_stack_index > this-> m_size)
                        { 
                            throw OutOfBoundsException(array_stack_index);
                        }
            return m_data[array_stack_index];
        }
 
    #endif //Array_CPP


Point_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
//                                                      
//                                                  (---.Point_cpp---)
//  
    #include "Point.hpp"
 
 int number_of_point_constructor_calls          = 1 ;   
 int number_of_point_destructor_calls           = 1 ;  
 int number_of_point_assignment_operator_calls  = 1 ; 
 
 
                //----------- Implementation of Constructors -----------//
    Point::Point() : x(0) , y(0)            // Default constructor (implemented using colon syntax )                                    
            { 
            //  std::cout << "hi my default constructor\n\n\t";
            }                           
 
 
    Point::Point(const double newX ,const double newY) : x(newX)  , y(newY)     // Constructor 
            { 
        //      std::cout << " My Point constructor was called " << number_of_point_constructor_calls++ << " times " << "\n"; 
            }                   
 
    Point::Point(const double value ) : x(value)                // Second Constructor 
            { 
            //std::cout << "hi my constructor\n\n\t"; 
            }   
    Point::~Point()                                             // Destructor
            {
            //  std::cout << " My Point destructor was called " << number_of_point_destructor_calls++ << " times " << "\n"; 
            }                                    
 
    Point::Point (const Point& ObjectOfClassPoint)              // Copy constructor
            {
                //std::cout << "this is COPY constructor\n\n\t ";
                x = ObjectOfClassPoint.x;
                y = ObjectOfClassPoint.y;
            }
        
 
                //----------- Implementation of Accessor(s) member functions -----------//
    std::string Point::ToString() const
            {
            //  std::string s=Shape::ToString();                                
                std::ostringstream os;                          // std::stringstream object
                os << " Point (" << x << ", " << y << ") " ;    // customization of output and calling base class functuanality 
                return os.str();                                // str() function retrieve the string from the string buffer
            }
 
 
                //----------- Implementation of Calculators (additional functionality) member functions -----------//
    double  Point::Distance() const
 
            {
                return std::sqrt(pow(x,2) + pow(y,2));
            }
 
 
    double  Point::Distance(const Point   &ObjPt ) const
    
            {
                return std::sqrt(pow((x-ObjPt.x),2) + pow(y - ObjPt.y,2)); 
            }
 
 
            //----------- Implementation of Operators Overloading the class's member -----------//
    Point Point::operator  -  () const                                  // Negate the coordinates.          
        {
            return Point(-x,-y);
        }
 
    Point Point::operator  *  (double factor) const                     // Scale the coordinates.
        {
            return Point(x * factor, y * factor);
        }
 
    Point Point::operator  +  (const Point& ObjPoint) const             // Add coordinates.
        { 
            return Point(x + ObjPoint.x, y + ObjPoint.y);
        }
 
    bool Point::operator   == (const Point& ObjPoint) const             // Equally compare operator.    
        {
            return (x==ObjPoint.x)&(y==ObjPoint.y);
        }
 
    Point& Point::operator =  (const Point& ObjPoint)                           // Assignment operator.             
                {       
            //      std::cout << " My Point assignment operator was called " << number_of_point_assignment_operator_calls++ << " times " << "\n"; 
                    x=ObjPoint.x, y=ObjPoint.y;
                    return *this;                                               // The meaning of *this explained in this example (implementation) see comment out  
                }
 
    Point& Point::operator *= (double factor)                                   // Scale the coordinates & assign.      
        {
            x *= factor; 
            y *= factor;
 
            return *this ; 
        }
    
 
    Point& Point::operator += (const Point& ObjPoint)  
        {
                x += ObjPoint.x;
                y += ObjPoint.y;
 
                return *this;
        }
 
    Point& Point::operator -= (const Point& ObjPoint)
        {
                x -= ObjPoint.x;
                y -= ObjPoint.y;
 
                return *this;
        }
 
 
    //----------- Implementation of GLOBAL Ostream << Operator  -----------//
    std::ostream& operator << (std::ostream& out,const Point & ObjPoint)
            {
                return out << "[" << ObjPoint.x << "," << ObjPoint.y << "]" ; 
                
            }


Stack_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//                                                      
//                                                  (---.Stack_cpp---)
//  
#ifndef STACK_CPP // Preprocessor gates
#define STACK_CPP
 
    #include "Stack.hpp"
 
 
    //----------- Implementation of Constructors -----------//
    template<class T>                           
    Stack<T>::Stack()                   // Default constructor
        :m_array(new Array<T>()),m_current(m_array->ArrayCurrentIndex()) 
        {   //the current position is the last index of the Array
            
        }
 
    template<class T>
    Stack<T>::Stack(int size)                   
        :m_array(new Array<T>(size)),m_current(m_array->ArrayCurrentIndex())       
        {   //the current position is the last index of the Array
 
        }
 
    template<class T>
    Stack<T>::~Stack()                                      // Destructor
        {
            // delete m_array;      
        }
    
    //----------- Implementation of Accessor(s) member functions -----------//
    template<class T>
    int Stack<T>::StackCurrentIndex() const
        {
            return m_array->ArrayCurrentIndex();
        }
 
    //----------- Implementaion of Modificator(s) member(s) function -----------//
    
    template<class T>
    void Stack<T>::Push(const T& element) const
        {   
            m_array->SetElement(element,m_array->ArrayCurrentIndex()); 
            m_array->array_stack_index++;   
        }
 
    template<class T>
    T Stack<T>::Pop() const
        {   
            T result = m_array->GetElement(m_array->ArrayCurrentIndex()); 
            m_array->array_stack_index--;
            return result; 
        }
 
    //----------- Implementation of Operators Overloading the class's member -----------//
    template<class T>
    Stack<T>& Stack<T>::operator=(const Stack<T>& ObjStack) // Asignment operator
        {
            if(this!=&ObjStack)        //handle self assignment
            {
                this->Stack<T>::operator=(ObjStack);
                m_current = s.m_current;
            }
 
            return(*this);
        }
#endif


main_cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
                                                
//                      (---.main_cpp---)
//
//      Lib(s)
        #include <iostream>
 
//      Header(s)
        #include "Point.hpp"
        #include "Array.cpp"
        #include "Stack.cpp"
    //  #include "ArrayException.hpp"
    //  #include "StackException.hpp"
 
int main()
{
                            
 
        
    const unsigned int size_of_data_array = 10; 
 
    double data_x[size_of_data_array] =
                   {1830 , 190.1 , 1914 , 1900 , 1839  , 
                     1865 , 1914  , 1633 , 1656 , 18.95 } ; 
 
    double data_y[size_of_data_array] =
                 { 1903 , 1834 , 1812 , 1088 , 1789, 
                   19.47 , 1211 , 1969 , 1535 , 1628   } ; 
 
     
    // Creating an array of Point pointers 
    // with size_of_array elements on the heap.
    Point** MyArrayOfPointers = new Point*[size_of_data_array];         
        
   
    for (unsigned int i = 0 ; i <size_of_data_array; i++ )                      
        { 
    // Create for each element in the array a point on the heap.
            MyArrayOfPointers[i] = new Point(data_x[i],data_y[i]);                                                                                      
        }
 
    const unsigned int size_of_stack = 5; 
    const unsigned int too_big_index = size_of_stack + size_of_stack/2;
    const unsigned int index_of_loop = too_big_index;               //too_big_index; 
 
 
    Stack<Point> TESTPointStack(size_of_stack);
 
    
    std::cout << " Size of the Stack is:      " << size_of_stack << "\n";
    std::cout << "  Point data array is:      " << size_of_data_array << "\n";
    std::cout << "Index of loops for testing\nPush and Pop fucntions are: " << index_of_loop << "\n";
    
 
                std::cout << "\n\n\t\t --- TEST  of Stack Full Exception  --- " << std::endl;
 
    std::cout << "current possition is BEFORE pushing : " << TESTPointStack.StackCurrentIndex() << std::endl;
 
    try {
        for(unsigned int i = 0;i<index_of_loop;i++)
            {         
                 TESTPointStack.Push(*MyArrayOfPointers[i]); // 
            }
        }
         catch(StackException& ObjStackException)
            {
                 ObjStackException; 
            }
 
            catch(...)
                {
                    std::cout<<"An unidentified exception occured"<<std::endl;
                }
 
std::cout   << "\nLet's making sure the current index is not\nchanged when the Array class throws an exception." 
            << "\nSo currect index after a lot of incorrect usage of\nPush() function should be "
            << size_of_stack -1 << " let's see -> " 
            << TESTPointStack.StackCurrentIndex() 
            << " This is correct index "; 
 
    
                                    std::cout << "\n\n\t\t --- TEST of Stack Empty Exception --- " << std::endl;
    try {
        for(unsigned int i = 0; i<index_of_loop;i++)
            {
                std::cout << TESTPointStack.Pop() <<std::endl;
            }
        }
        catch(StackException& ObjStackException)
            {
                ObjStackException;
            }
 
            catch(...)
                {
                    std::cout<<"An unidentified exception occured"<<std::endl;
                }
 
std::cout   << "\nLet's making sure the current index is not\nchanged when the Array class throws an exception." 
            << "\nSo currect index after a lot of incorrect usage of\nPop() function should be 0 let's see -> " 
            << TESTPointStack.StackCurrentIndex() 
            << " This is correct index "; 
 
 
 
 
 
    std::cout << "\n\n\n";
    std::cout << std::endl;
    return 0;
}


Сейчас Stack destructor имплементация закоментина и все работает нормально ! Если раскоментировать(destructor имплементацию) то проект валиться на самой первой строчки. Если сделать не слоенное exception handling на setElement and GetElement а просто то все работает нормально если даже есть имплементация Stack destructor .
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
In main.cpp
try {
        for(unsigned int i = 0;i<index_of_loop;i++)
            {         
                 TESTPointStack.Push(*MyArrayOfPointers[i]); // 
            }
        }
        // catch(StackException& ObjStackException)
    catch ( ArrayException& objArrayException )
            {
        //       ObjStackException; 
                std::cout << objArrayException.GetMessage() ;
            }
 
            catch(...)
                {
                    std::cout<<"An unidentified exception occured"<<std::endl;
                }
 
try {
        for(unsigned int i = 0; i<index_of_loop;i++)
            {
                std::cout << TESTPointStack.Pop() <<std::endl;
            }
        }
    //  catch(StackException& ObjStackException)
    catch ( ArrayException& objArrayException )
            {
            //  ObjStackException;
                std::cout << objArrayException.GetMessage() ;
            }
 
            catch(...)
                {
                    std::cout<<"An unidentified exception occured"<<std::endl;
                }
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
in array.cpp 
 
void Array<T>::SetElement(const T& ObjType, unsigned int index)
            {
                array_stack_index = index; 
                    std::cout << "Set Element[" << index << "]<-  "; 
                    if (array_stack_index >= m_size || array_stack_index < 0 )
                        {   
                        //  try 
                        //      {
                                    //std::cout << " Data wasn't setted"; 
                                    throw OutOfBoundsException(array_stack_index--);
                        //      }
                        //      catch(OutOfBoundsException) 
                        //          {
                        //            throw StackFullException();
                        //          }
                        }
 
 
                    std::cout << ObjType << "\n"; 
                    m_data[array_stack_index] = ObjType;
            }
 
template <class T> 
        T& Array<T>::GetElement(const unsigned int index) 
            {
                array_stack_index = index; 
                //std::cout << "GetElement[" << index <<"] ->" ;
                    if (array_stack_index >= m_size || array_stack_index < 0)
                        {       
                        //  try {
                            std::cout << " Data wasn't getted"; 
                            throw OutOfBoundsException(array_stack_index++);
                        //      }
                        //      catch(OutOfBoundsException)
                        //          {
                        //              throw   StackEmptyException();
                        //          }
 
                        }
 
                return m_data[array_stack_index];
            }

Подскажите в чем дело ????

Добавлено через 5 часов 45 минут
Ребята выручайте не проходите мимо ))) пожалуйста !

Добавлено через 1 час 26 минут
help!
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
Текущее время: 12:08. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru