EssentialC++第六章总结+课后习题+踩雷清单

我不是女神ヾ 2023-02-14 15:46 6阅读 0赞

### 目录 ###

*  总结
 *  课后习题
 *   *  6.1改写非模板类称为模板类
     *  6.2 改写非模板类成模板类，并扩充其功能，使它能够通过堆内存来支持任意行列大小。分配/释放内存的操作，请在构造函数/析构函数中进行
 *  踩雷清单

# 总结 #

*  讲了模板类，这是在原基础上把对象类型抽离出来，变成template<typename 占位符>这种形式。
 *  然后怎么定义模板类，模板成员函数，和定义一般模板函数大同小异，抽离出来类型就可以，注意别忘把类型抽离出来，然后注意不该改成模板类型的别改成模板类型（比如大小、长度，这只能是整数，名字，这只能是string型）
 *  关于模板样式的形参，写这样的形式：const 模板类型名& 形参名，因为模板类型也许是内置类型也许是class类型，这样的格式避免复制所带来巨大的开销，使程序效率降低。
 *  模板参数可以是<类型名 变量名（可以=默认参数值）>这种形式。
 *  模板类最好搭配着模板模板函数。
 *  `返回类型 函数名(*&参数名)`，这里的\*&可以让我们修改形参指针本身，也可以修改形参指针所指的对象。

# 课后习题 #

## 6.1改写非模板类称为模板类 ##

template<typename elemType>
    class example{
        
    public:
        example(const elemType &min,const elemType &max);//一定要const加&，因为elemType不知道啥类型，
        //万一是class类型，不加const和&就意味着传值传递以及可能被认为会改变形参，这将会造成程序可读性变差和效率降低。
        example(const elemType *array,int size);
        elemType& operator[](int index);//size、index这种不是想改变类型就改变类型的变量，就保持其原类型即可。
        bool operator==(const example1&)const;
        bool insert(const elemType*,int);
        bool insert(const elemType&);
        elemType min()const{
        return _min;}
        elemType max()const{
        return _max;}
        void min(const elemType&);
        void max(const elemType&);
        int count(const elemType &value)const;
    private:
        int size;//数组元素个数必须为整数，不可以是其他。
        elemType *parray;
        elemType _min;
        elemType _max;
    };

## 6.2 改写非模板类成模板类，并扩充其功能，使它能够通过堆内存来支持任意行列大小。分配/释放内存的操作，请在构造函数/析构函数中进行 ##

我不知道咋回事，书上源代码也过不了。就直接搬源码来了。

#include <iostream>
    #include <cassert>
    using namespace std;
    
    template <typename elemType>
    class Matrix
    {
        
        friend Matrix<elemType>
        operator+( const Matrix<elemType>&, const Matrix<elemType>& );
    
        friend Matrix< elemType >
        operator*( const Matrix<elemType>&, const Matrix<elemType>& );
    
    public:
        Matrix( int rows, int columns );
        Matrix( const Matrix& );
        ~Matrix(){
         delete [] _matrix; }
        Matrix& operator=( const Matrix& );
    
        void operator+=( const Matrix& );
        elemType& operator()( int row, int column )
            {
         return _matrix[ row * cols() + column ]; }
    
        const elemType& operator()( int row, int column ) const
            {
         return _matrix[ row * cols() + column ]; }
    
        int rows() const {
         return _rows; }
        int cols() const {
         return _cols; }
    
        bool same_size( const Matrix &m ) const
             {
         return rows() == m.rows() && cols() == m.cols(); }
    
        bool comfortable( const Matrix &m ) const
             {
         return ( cols() == m.rows() ); }
    
        ostream& print( ostream& ) const;
    
    protected:
        int  _rows;
        int  _cols;
        elemType *_matrix;
    };
    
    template <typename elemType>
    inline ostream& operator<<( ostream& os, const Matrix<elemType> &m )
        {
         return m.print( os ); }
    
    // end of Matrix.h
    template <typename elemType>
    Matrix< elemType >
    operator+( const Matrix<elemType> &m1, const Matrix<elemType> &m2 )
    {
        
        assert( m1.same_size( m2 ) != 0 );
    
        Matrix<elemType> result( m1 );
        result += m2;
        return result;
    }
    
    template <typename elemType>
    Matrix<elemType>
    operator*( const Matrix<elemType> &m1, const Matrix<elemType> &m2 )
    {
        
        assert( m1.comfortable( m2 ) != 0 );
        Matrix<elemType> result( m1.rows(), m2.cols() );
    
        for ( int ix = 0; ix < m1.rows(); ix++ ) {
        
    	   for ( int jx = 0; jx < m1.cols(); jx++ ) {
        
    	         result( ix, jx ) = 0;
    	         for ( int kx = 0; kx < m1.cols(); kx++ )
    		        result( ix, jx ) += m1( ix, kx ) * m2( kx, jx );
    	   }
        }
        return result;
    }
    
    template <typename elemType>
    void Matrix<elemType>::operator+=( const Matrix &m )
    {
        
        assert( same_size( m ) != 0 );
        register int matrix_size = cols() * rows();
    
        for ( int ix = 0; ix < matrix_size; ++ix )
            ( *( _matrix + ix )) += ( *( m._matrix + ix ));
    }
    
    template <typename elemType>
    ostream& Matrix<elemType>::print( ostream &os ) const
    {
        
        register int col = cols();
        register int matrix_size = col * rows();
    
        for ( int ix = 0; ix < matrix_size; ++ix )
        {
        
    	  if ( ix % col == 0 ) os << endl;
    	  os << ( *( _matrix + ix )) << ' ';
        }
    
        os << endl;
        return os;
    }
    
    template <typename elemType>
    Matrix<elemType>::Matrix( const Matrix & rhs )
    {
        
    	_rows = rhs._rows; _cols = rhs._cols;
    	int mat_size = _rows * _cols;
       _matrix = new elemType[ mat_size ];
    	for ( int ix = 0; ix < mat_size; ++ix )
             _matrix[ ix ] = rhs._matrix[ ix ];
    
    }
    
    template <typename elemType>
    Matrix<elemType>& Matrix<elemType>::
    operator=( const Matrix &rhs )
    {
        
    	if ( this != &rhs )
       {
        
        	    _rows = rhs._rows; _cols = rhs._cols;
    	     int mat_size = _rows * _cols;
    	     delete [] _matrix;
    	     _matrix = new elemType[ mat_size ];
    	     for ( int ix = 0; ix < mat_size; ++ix )
                  _matrix[ ix ] = rhs._matrix[ ix ];
        }
        return *this;
    }
    
    template <typename elemType>
    Matrix<elemType>::Matrix( int rows, int columns )
                : _rows( rows ), _cols( columns )
    {
        
        int size = _rows * _cols;
        _matrix = new elemType[ size ];
        for ( int ix = 0; ix < size; ++ix )
              _matrix[ ix ] = elemType();
    }
    
    
    #include <fstream>
    void ex6_2()
    {
        
    	ofstream log( "logmatrix.txt" );
    	if ( ! log )
    		{
         cerr << "can't open log file!\n"; return; }
    
    	Matrix<float> identity( 4, 4 );
        log << "identity: " << identity << endl;
    
    	float ar[16]={
        
    		1., 0., 0., 0., 0., 1., 0., 0.,
    		0., 0., 1., 0., 0., 0., 0., 1. };
    
    	for ( int i = 0, k = 0; i < 4; ++i )
    		for ( int j = 0; j < 4; ++j )
    		    identity( i, j ) = ar[ k++ ];
    
    	log << "identity after set: " << identity << endl;
    
    	Matrix<float> m( identity );
    	log << "m: memberwise initialized: " << m << endl;
    
    	Matrix<float> m2( 8, 12 );
    	log << "m2: 8x12: " <<  m2  << endl;
    
    	m2 = m;
    	log << "m2 after memberwise assigned to m: " << m2 << endl;
    
    	float ar2[16]={
        
    		1.3f, 0.4f, 2.6f, 8.2f, 6.2f, 1.7f, 1.3f, 8.3f,
    		4.2f, 7.4f, 2.7f, 1.9f, 6.3f, 8.1f, 5.6f, 6.6f };
    
    	Matrix<float> m3( 4, 4 );
    
    	for ( int ix = 0, kx = 0; ix < 4; ++ix )
    		for ( int j = 0; j < 4; ++j )
    		    m3( ix, j ) = ar2[ kx++ ];
    
    	log << "m3: assigned random values: " << m3 << endl;
    
    	Matrix<float> m4 = m3 * identity;
    	log << m4 << endl;
    
    	Matrix<float> m5 = m3 + m4;
    	log << m5 << endl;
    
    	m3 += m4;
    	log << m3 << endl;
    }
    
    #include <vector>
    #include <algorithm>
    using namespace std;
    
    void test_rotate()
    {
        
    	char ch[] = "boohiss!!";
    	rotate( ch, ch+3, ch+7 );
    	cout << ch << endl;
    }
    
    int main()
    {
        
    	ex6_2();
    	test_rotate();
    	return 0; // unnecessary but quiets vc++
    }

# 踩雷清单 #

*  using namespace std;  
    //应该是没有加using这行导致的error  
    //error: template argument 1 is invalid|  
    //error: ‘elemTytpe’ was not declared in this scope|  
    C++里边的assert宏在头文件CASSERT(`#include<cassert>`)里边，**主要是测试程序中这个条件：正确则不作任何操作。错误则输出信息并停止程序。**

至此，第六章完结！