C++中模板分离问题

kingoftime3

在一本C++模板书中看到，如果在a.h文件里定义了一个类，实现类中的函数最好也写在a.h里，因为如果写在另一个文件里会让编译器找不到特定的函数声明。
但我将其中的函数定义在a.cpp里，照样可以运行， 是gcc的优化吗？
一起很纠结，如果像书上的那种写好几个文件还特化的方法太麻烦了

AD8018

模板分离只是一个传说

benbrick

假如是函数，h中只写声明， 但是假如是模板，那么必须把所有实现写在h中，否则编译器无法在编译时根据模板完成函数或者类的构建。因为编译总是以cpp文件为单位的。

kingoftime3

回复 3# benbrick


    但是在g++里将实现写到相应有cpp里可以正常使用，这是怎么回事？

NightCrawler

以前的编译器不支持这种模板分离编译

changsha

回复  benbrick


    但是在g++里将实现写到相应有cpp里可以正常使用，这是怎么回事？
kingoftime3 发表于 2011-05-06 00:04

    不可能！贴代码出来

captivated

不可能！贴代码出来
changsha 发表于 2011-05-06 02:09

    嗯嗯嗯嗯嗯嗯嗯呃...

kingoftime3

回复 6# changsha


    matrix.h

1. 
   
2. #ifndef MATRIX_H
   
3. #define MATRIX_H
   
4. #include <iostream>
   
5. 
   
6. using namespace std;
   
7. 
   
8. template<typename T>
   
9. class Matrix
   
10. {
    
11. private:
    
12.         class Matrix1D;
    
13. public:
    
14.         int rows,cols;
    
15.         T *data;
    
16.         Matrix(int _rows, int _cols, T *data);
    
17.         ~Matrix();
    
18.         Matrix operator+(const Matrix &mat);
    
19.         Matrix operator*(const Matrix &mat);
    
20.         bool operator==(const Matrix &mat);
    
21.         Matrix1D operator[](int row){Matrix1D m1d(row, cols, data);return m1d;}
    
22.         operator T();
    
23. };
    
24. 
    
25. template<typename T>
    
26. ostream& operator<<(ostream& os, const Matrix<T> &mat);
    
27. 
    
28. template<typename T>
    
29. istream& operator>>(istream& is, Matrix<T> &mat);
    
30. 
    
31. 
    
32. template<typename T>
    
33. class Matrix<T>::Matrix1D
    
34. {
    
35. private:
    
36.         int inrow, cols;
    
37.         T *indata;
    
38. public:
    
39.         Matrix1D(int _row, int _cols, T *_data):inrow(_row), cols(_cols),indata(_data){}
    
40.         T operator[](int col){return indata[inrow*cols+col];}
    
41. };
    
42. 
    
43. template<typename T>
    
44. class Vector3:public Matrix<T>
    
45. {
    
46. public:
    
47.         Vector3(T t1, T t2, T t3):Matrix<T>(3, 1, NULL){
    
48.                 this->data[0]=t1;this->data[1]=t2;this->data[2]=t3;}
    
49.         T operator[](int index){return this->data[index];}
    
50. };
    
51. #endif
    

复制代码

matrix.cpp

1. 
   
2. #include "matrix.h"
   
3. #include <string.h>
   
4. #include <fstream>
   
5. #ifdef DEBUG
   
6. #include <assert.h>
   
7. #endif
   
8. 
   
9. template<typename T>
   
10. Matrix<T>::Matrix(int _rows, int _cols, T *_data)
    
11. {
    
12.         rows=_rows,cols=_cols;
    
13.         data = new T[rows*cols];
    
14.         if (_data == NULL)
    
15.         {
    
16.                 bzero(data, rows*cols);
    
17.         }
    
18.         else
    
19.         {
    
20.                 for(int i=0; i < rows*cols; i++)
    
21.                 {
    
22.                         data[i] = _data[i];
    
23.                 }
    
24.         }
    
25. }
    
26. 
    
27. template<typename T>
    
28. Matrix<T>::~Matrix()
    
29. {
    
30.         //std::cout << "~Matrix" << std::endl;
    
31.         if(data != NULL)
    
32.         {
    
33.                 delete[] data;
    
34.         }
    
35. }
    
36. 
    
37. template<typename T>
    
38. Matrix<T> Matrix<T>::operator+(const Matrix<T> &mat)
    
39. {
    
40. #ifdef DEBUG
    
41.         assert(this->rows==mat.rows && this->cols==mat.cols);
    
42. #endif
    
43.         Matrix<T> result(rows, cols, NULL);
    
44.         for(int i=0; i < rows*cols; i++)
    
45.         {
    
46.                 result.data[i] = this->data[i]+mat.data[i];
    
47.         }
    
48.         return result;
    
49. }
    
50. 
    
51. template<typename T>
    
52. Matrix<T> Matrix<T>::operator*(const Matrix<T> &mat)
    
53. {
    
54. #ifdef DEBUG
    
55.         assert(cols==mat.rows);
    
56. #endif
    
57.         Matrix<T> result(rows, mat.cols, NULL);
    
58.         for(int i=0; i < result.rows; i++)
    
59.         {
    
60.                 for(int j=0; j < result.cols; j++)
    
61.                 {
    
62.                         for(int k=0; k < cols; k++)
    
63.                         {
    
64.                                 result.data[i*result.cols+j] += this->data[i*cols+k]*mat.data[k*mat.cols+j];
    
65.                         }
    
66.                 }
    
67.         }
    
68.         return result;
    
69. }
    
70. 
    
71. template<typename T>
    
72. ostream& operator<<(ostream& os, const Matrix<T> &mat)
    
73. {
    
74. #ifdef DEBUG
    
75.         assert(mat.rows!=0&&mat.cols!=0);
    
76. #endif
    
77.         os << mat.rows << "\t" << mat.cols << endl;
    
78.         for(int i=0; i < mat.rows; i++)
    
79.         {
    
80.                 for(int j=0; j < mat.cols; j++)
    
81.                 {
    
82.                         os << mat.data[i*mat.cols+j] << "\t";
    
83.                 }
    
84.                 os << endl;
    
85.         }
    
86.         return os;
    
87. }
    
88. 
    
89. template<typename T>
    
90. istream& operator>>(istream& is, Matrix<T> &mat)
    
91. {
    
92.         if(mat.data != NULL)
    
93.                 delete[] mat.data;
    
94.         is >> mat.rows >> mat.cols;
    
95.         mat.data = new T[mat.rows*mat.cols];
    
96.         for(int i = 0; i < mat.rows; i++)
    
97.         {
    
98.                 for(int j = 0; j < mat.cols; j++)
    
99.                 {
    
100.                         is >> mat.data[i*mat.cols+j];
     
101.                 }
     
102.         }
     
103.         return is;
     
104. }
     
105. 
     
106. template<typename T>
     
107. Matrix<T>::operator T()
     
108. {
     
109. #ifdef DEBUG
     
110.         assert(rows==1&&cols==1);
     
111. #endif
     
112.         return data[0];
     
113. }
     
114. 
     
115. template<typename T>
     
116. bool Matrix<T>::operator==(const Matrix &mat)
     
117. {
     
118.         if(this->rows==mat.rows&&this->cols==mat.cols)
     
119.         {
     
120.                 for(int i = 0; i < this->rows*this->cols; i++)
     
121.                 {
     
122.                         if(this->data[i] != mat.data[i])
     
123.                                 return false;
     
124.                 }
     
125.                 return true;
     
126.         }
     
127.         return false;
     
128. }
     

复制代码

changsha

回复  changsha


    matrix.hmatrix.cpp
kingoftime3 发表于 2011-05-08 13:51

    你只是定义了模板类但是从来没有实例化，当然没有问题

kingoftime3

回复 9# changsha


    这样用也没有问题

1. int main()
   
2. {
   
3.                 double d[] = {1,2,3,4};
   
4.                 Matrix<double> m(2,2,d);
   
5.                 cout << m << endl;
   
6.                 return 0;
   
7. }

复制代码