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

Статическая переменная в шаблоне - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ расчет значения e^x(x это степень) http://www.cyberforum.ru/cpp-beginners/thread633411.html
есть задача,в котором нужно рассчитать значение e^x. Проблема в том что я даже понятие не имею что это такое это экспоненто в степени x. Но, недавно написал программу которая высчитывает экспоненту...
C++ Получение числа из переменной К примеру: int s=326; Как можно получить числа 3,2 и 6? ( Я делаю небольшую игру и мне необходимо это для вывода очков ) http://www.cyberforum.ru/cpp-beginners/thread633393.html
C++ Битовое ИЛИ. Пердача нескольких констант в один параметр функции
здраствуйте! иногда в примерах програмного кода замечаю, что несколько констант передаются в один парметр функции с помщью битового или. так, например, изучая понемногу d3dx9 решил всетаки спросить в...
Считывание символов из строки C++
Здравствуйте, форумчане. Можете подсказать, каким образом можно считать из RichTextBox символы до какого либо знака-разделителя, записать их в переменную и потом, после этого знака, тоже считать и...
C++ delete this http://www.cyberforum.ru/cpp-beginners/thread633372.html
Какие последствия могут быть при выполнении команды delete this; из какой-нибудь функции члена?
C++ visual c++, как сделать форму невидемой помогите, как в Visual Studio 2005 С++, сделать программу невидимой? подробнее

Показать сообщение отдельно
Leeto
7 / 7 / 0
Регистрация: 23.12.2011
Сообщений: 372
Записей в блоге: 1

Статическая переменная в шаблоне - C++

05.08.2012, 22:29. Просмотров 1578. Ответов 5
Метки (Все метки)

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
//                                                      
//                                                  (---.Array_hpp---)
//
#ifndef Array_HPP   // Preprocessor gates
#define Array_HPP
 
    #include <sstream>
    #include <iostream>
    #include <exception>
 
    template <class Type>   //Remove the "=double" default parameter.
    class Array
        {
    
            private:                // Declaration of private data members 
              unsigned int m_size;
              Type*        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;
                //----------- Declaration of Constructors -----------//
              Array();                                  // Default constructor
              Array(const unsigned int new_size);       // Constructor 
              Array(const Array<Type>& ObjArray);       // Copy constructor
              ~Array();                                 // Destructor
 
              //----------- Declaration of  Accessors member functions -----------//
              Type& GetElement(const unsigned int index) const;
 
              static int DefaultSize() ;
              static void DefaultSize( int newSize) ;
 
                          //----------- Declaration of Modificator(s) member functions -----------//
              void SetElement(const Type& ObjType, const unsigned int index);
              void Swap(Array& ObjArray);  
 
              //----------- Declaration of Operators Overloading the class's members -----------//
              Array<Type>& operator =   (const Array& ObjArray);                //Const correctness here.
              const Type& operator  []  (unsigned int index) const;
              Type& 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
//*/
 
//  #include "Array.inl"
#endif //  #ifndef Array_HPP is CLOSED


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
//                                                      
//                                                  (---.Array_CPP---)
//  
 
    #ifndef Array_CPP   // Preprocessor gates
    #define Array_CPP
 
        #include "Array.hpp"
                                    
    template <class Type>
    int Array<Type>::m_size_default = 10;
                    //----------- Implementation of Constructors -----------//
        template <class Type>
        Array<Type>::Array() : m_size(10), m_data(0)
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(unsigned int new_size) 
            : m_size(new_size), m_data(new Type[new_size])
            { 
 
            }
 
        template <class Type>
        Array<Type>::Array(const Array& ObjArray) : m_data(0), m_size(0)
            {
              if(!ar.m_data) {return;}
 
              Array tmp; //Copy construct into another temporary array, this way, if something throws, tmp will clean itself up.
 
              //Create the array
              tmp.m_data = new Type[ar.m_size];
              tmp.m_size = ar.m_size;
 
              //Copy the array elements
              for(unsigned int i = 0; i < tmp.m_size; ++i)
                {tmp.m_data[i] = ar.m_data[i];}
 
              //All done! swap into this!
              this->Swap(tmp);
            }
 
 
        template <class Type>
        Array<Type>::~Array()
            {
              //Technically, the if is not necessary
              if(m_data)
              {
                delete[] m_data;
                m_data = 0;
              }
 
              //Not necessary either, but just to be clean
              m_size = 0;
            }
 
        //----------- Implementation of Accessor(s) member functions -----------//
 
        template <class Type> 
        Type& Array<Type>::GetElement(const unsigned int index) const
            {
                std::cout 
                << "GetElement -> " ;
    
                    if (index >= m_size || index < 0)
                        { 
                            throw std::out_of_range 
                                ("Out of range error in void Array<Type>::GetElement");
                        } 
 
                return m_data[index];
            }
 
        
        //----------- Implementaion of Modificator(s) member(s) function -----------//
 
        template <class Type>
        void Array<Type>::Swap(Array& ObjArray)
            {
                //std::swap()  - try to implement std swap function 
              Type* data = m_data;
       unsigned int size = m_size;
              m_data     = ObjArray.m_data;
              m_size     = ObjArray.m_size;
         ObjArray.m_data = data;
         ObjArray.m_size = size;
            }
 
        template <class Type> 
        void Array<Type>::SetElement(const Type& ObjType,unsigned int index)
            {
 
                    if (index >= m_size || index < 0 )
                        { 
                            throw std:: out_of_range ("out of range error in void Array<Type>::SetElement");
                        }
                    m_data[index] = ObjType;
            //  std::cout << "Set Element <- " << ObjType  << std::endl;
            }
 
        template <typename Type>
        int Array<Type>::DefaultSize() 
            { 
                return m_size_default;
            }
 
        template <typename Type>
        void Array<Type>::DefaultSize( int newSize) 
            { 
                m_size_default = newSize; 
            }
 
 
        //----------- Implementation of Operators Overloading the class's member -----------//
 
        template <class Type>
        Array<Type>& Array<Type>::operator = (const Array& ObjArray)
            {
              //Check self assign:
              if(this == &ObjArray) {return *this;}
 
              Array<Type> copy(ObjArray);   //Create a copy of ObjArray; If this fails, then *this will not be changed, and nothing will leak
 
                                            //Succeeded creating copy. Now we can put it inside this
              this->Swap(copy);             //And then swap the copy into this!
 
              return *this;
            }
 
        template <class Type> 
        Type& Array<Type>::operator [] (unsigned int index) 
            {
                cout << "Array [] operator" << endl;
 
                if (index >= this->m_size)
                    {
                        cout << "i am hreeeee" << endl;
                        return this->m_data[0];
                    }
                return m_data[index];
            }
 
        template <class Type> 
        const Type& Array<Type>::operator [] (unsigned int index) const
        {   
            if (index > this-> m_size)
                    {
                        std::cout 
                            << "OUT OF BOUND ";
                        return this->m_data[0];
                    }
            return m_data[index];
        }
 
 
// /*
    #endif //Array_CPP
 
//      */


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
//                                                      
//                                                  (---.main_cpp---)
//
        #include "Array.hpp"
        #include <iostream>
        #include <exception>
 
        using namespace std;
 
 
 
int main()
{
    
 
    Array<int> intArray1;
    Array<int> intArray2;
    Array<double> doubleArray;
 
    cout<<intArray1.DefaultSize()<<endl;
    cout<<intArray2.DefaultSize()<<endl;
    cout<<"double array old defaul size " << doubleArray.DefaultSize()<< "\n\n";
 
    intArray1.DefaultSize(15);
   
    cout<<intArray1.DefaultSize()<<endl;
    cout<<intArray2.DefaultSize()<<endl;
    cout<<"\n\n double array new defaul size " << doubleArray.DefaultSize()<< "\n\n";
 
    return 0 ; 
    
}


Допустим есть вот какой вот проект
Соль его в том что у Array класса есть переменная static. И майн доходчиво должно демонстрировать свойства этой static переменной... но только не такому быдло недо кодеру как я... пожалуйста объясните что происходит в main.cpp и как на этом примере работает static
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru