类与类模板的嵌套 

  1 /* 嵌套类 与 嵌套类模板 */
  2 
  3 #include<iostream>
  4 
  5 using namespace std;
  6 
  7 // mynewclass  是 myclass 的嵌套类
  8 // 嵌套类就是一个类的内部完全实现
  9 // 允许无限嵌套
 10 // 嵌套类与继承是一样的，母体最后创建 最先销毁 ，子体最先创建最后销毁
 11 class myclass
 12 {
 13 public:
 14     myclass()
 15     {
 16         cout << "myclass new" << endl;
 17     }
 18 
 19     ~myclass()
 20     {
 21         cout << "myclass delete" << endl;
 22     }
 23     class mynewclass// 嵌套类
 24     {
 25     public:
 26         mynewclass()
 27         {
 28             cout << "mynewclass new" << endl;
 29         }
 30 
 31         ~mynewclass()
 32         {
 33             cout << "mynewclass delete" << endl;
 34         }
 35     }my2;
 36 
 37     mynewclass my1;
 38 };
 39 
 40 void main()
 41 {
 42     
 43     myclass *p = new myclass;
 44     delete p;
 45 
 46     cin.get();
 47 }
 48 
 49 //---------------------------------------------------------
 50 
 51 /* 嵌套类模板 */
 52 
 53 #include<iostream>
 54 
 55 using namespace std;
 56 
 57 // 类模板内部可以嵌套类
 58 template<class T>
 59 class A
 60 {
 61 public:
 62     T t;
 63     
 64     A()
 65     {
 66         cout << "A create" << endl;
 67     }
 68     
 69     ~A()
 70     {
 71         cout << "A delete" << endl;
 72     }
 73 
 74     class mynewclass// 嵌套在类模板里面的类
 75     {
 76     public:
 77         mynewclass()
 78         {
 79             cout << "mynewclass new" << endl;
 80         }
 81 
 82         ~mynewclass()
 83         {
 84             cout << "mynewclass delete" << endl;
 85         }
 86     }my;
 87 
 88 };
 89 
 90 
 91 
 92 void main()
 93 {
 94     A<double> a;
 95 
 96 
 97     cin.get();
 98 }
 99 
100 //---------------------------------------------------------
101 
102 #include<iostream>
103 
104 using namespace std;
105 
106 // 类模板内部可以嵌套类 还可以嵌套类模板（实例化的时候必须明确类型，明确母体类模板的类或者已知数据类型）
107 // 类的内部可以嵌套类 可以嵌套类模板（对象必须是已知数据类型）
108 
109 class myclass
110 {
111 public:
112     myclass()
113     {
114         cout << "myclass new" << endl;
115     }
116 
117     ~myclass()
118     {
119         cout << "myclass delete" << endl;
120     }
121 
122     template <class TX>
123     class mynewclass
124     {
125     public:
126         TX tx1;
127         mynewclass()
128         {
129             cout << "mynewclass new" << endl;
130         }
131 
132         ~mynewclass()
133         {
134             cout << "mynewclass delete" << endl;
135         }
136     };
137 
138     mynewclass<int> my1;
139 };
140 
141 
142 template<class T>
143 class A
144 {
145 public:
146     T t;
147     
148     A()
149     {
150         cout << "A create" << endl;
151     }
152     
153     ~A()
154     {
155         cout << "A delete" << endl;
156     }
157     
158     template <class TX>
159     class mynewclass// 嵌套在类模板里面的类
160     {
161     public:
162         TX tx1;
163 
164         mynewclass()
165         {
166             cout << "mynewclass new" << endl;
167         }
168 
169         ~mynewclass()
170         {
171             cout << "mynewclass delete" << endl;
172         }
173     };// 类模板不允许直接在类的实体后定义
174 
175 //    mynewclass<double> my1;
176  mynewclass<T> my1;
177 
178 };
179 
180 
181 
182 void main()
183 {
184     
185     myclass my1;
186 
187     cin.get();
188 }

 

posted on 2015-06-11 16:06  Dragon-wuxl  阅读(1159)  评论(0)    收藏  举报

导航