C++中模板分离问题

Question

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

Answer 1

模板分离只是一个传说

Answer 2

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

Answer 3

回复 3# benbrick

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

Answer 4

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

Answer 5

回复  benbrick

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

    不可能！贴代码出来

Answer 6

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

    嗯嗯嗯嗯嗯嗯嗯呃...

Answer 7

回复 6# changsha

    matrix.h

2. #ifndef MATRIX_H
3. #define MATRIX_H
4. #include <iostream>
6. using namespace std;
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. };
25. template<typename T>
26. ostream& operator<<(ostream& os, const Matrix<T> &mat);
28. template<typename T>
29. istream& operator>>(istream& is, Matrix<T> &mat);
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. };
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

2. #include "matrix.h"
3. #include <string.h>
4. #include <fstream>
5. #ifdef DEBUG
6. #include <assert.h>
7. #endif
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. }
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. }
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. }
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. }
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. }
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. }
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. }
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. }

复制代码

Answer 8

回复  changsha

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

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

Answer 9

回复 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. }

复制代码