自定义C++一元多项式类

 自己定义了一个一元多项式的简单类，主要是用来实现一个简单的框架，另外就是验证编译器默认情况下会为我们的类添加那些构造函数。

 

1. /* 
2. * polynomial.h 
3. * 该类定义一元多项式 
4. * MAXDEGREE ：定义该类最大可表示的次数 
5. * MINCOEFF：定义绝对值最小的系数 
6. * coefficient[  ] :存放一元多项式的系数 
7. * currentDegree：存放当前对象的最高次数 
8. * 构造函数：默认构造函数设置coefficient[]和currentDegree全为0 
9. *                可以使用一个float数组和数组长度来构造一个一元多项式 
10. * display( ) :用于显示对象的信息 
11. * value(  ):计算给定x时的一元多项式的值 
12. * operator +/-():计算多项式之间的加减 
13. * power(  ) ：用于计算给定x值的x的degree次幂的值 
14. */ 
15. class polynomial 
16. { 
17. public: 
18.     polynomial(  ); 
19.     polynomial( float coeff [ ],int size ); 
20.     ~polynomial(  ){} 
21.  
22.     void  display(  ); 
23.     double value(float xx); 
24.  
25.     friend polynomial operator +( const polynomial& one,const polynomial& two ); 
26.     friend polynomial operator -( const polynomial& one,const polynomial& two ); 
27.      
28. private: 
29.     double power( float xx,int degree ); 
30.      
31.          
32. private: 
33.     static const int MAXDEGREE=20; 
34.     static const float MINCOEFF=0.000001; 
35.     float coefficient[ MAXDEGREE+1 ]; 
36.     int currentDegree; 
37.  
38. }; 

 

1. /* 
2.  *polynomial.cpp 
3.  */ 
4. #include "polynomial.h" 
5. #include <iostream> 
6. #include <cstdlib> 
7.  
8. polynomial::polynomial(  ) 
9. { 
10.     for( int i=0;i<MAXDEGREE+1;i++ ) 
11.         coefficient[ i ]=0.0; 
12.     currentDegree=0; 
13.      
14. } 
15.  
16. polynomial::polynomial( float coeff [  ],int size ) 
17. { 
18.    if( size>MAXDEGREE ) 
19.        { 
20.            std::cout<<"the degree is bigger than the MAXDEGREE\n"; 
21.            exit( -1 ); 
22.             
23.        } 
24.    if( coeff==NULL ) 
25.        { 
26.            std::cout<<"you have input nothing\n"; 
27.            exit( -1 ); 
28.             
29.        } 
30.  
31.    for( int i=0;i<size;i++ ) 
32.        coefficient[ i ]=coeff[ i ]; 
33.  
34.    currentDegree=size-1; 
35.  
36. } 
37.  
38. void polynomial::display(  ) 
39.     { 
40.         std::cout<<"The MAXDEGREE = "<<MAXDEGREE<<"\n"; 
41.          
42.         std::cout<<coefficient[ 0 ]; 
43.         for( int i=1;i<currentDegree+1;++i ) 
44.             { 
45.                 if( (coefficient[ i ] > (0.0-MINCOEFF)) && (coefficient[ i ] <MINCOEFF )) ; 
46.                 else 
47.                 { 
48.                     if( coefficient[ i ]>0.0 ) 
49.                         std::cout<<"+"<<coefficient[ i ]<<"x^"<<i; 
50.                     else 
51.                         std::cout<<coefficient[ i ]<<"x^"<<i; 
52.                 } 
53.             } 
54.         std::cout<<std::endl; 
55.     } 
56.  
57. double polynomial::power( float xx,int degree ) 
58.     { 
59.         double temp=1.0; 
60.         while( degree-- ) 
61.             temp*=xx; 
62.         return temp; 
63.          
64.     } 
65.  
66. double polynomial::value( float xx ) 
67.     { 
68.         double sum=0.0; 
69.         for( int i=0;i<currentDegree+1;++i ) 
70.             { 
71.                 sum = sum+coefficient[ i ]*power( xx,i ); 
72.                  
73.             } 
74.         return sum; 
75.          
76.     } 
77.  
78. polynomial operator +( const polynomial& one,const polynomial& two ) 
79.     { 
80.         polynomial temp; 
81.          
82.         int biggerDegree=( one.currentDegree > two.currentDegree ?one.currentDegree:two.currentDegree ); 
83.         for( int i=0;i<biggerDegree+1;++i ) 
84.             { 
85.                 temp.coefficient[ i ] = one.coefficient[ i ]+two.coefficient[ i ]; 
86.                  
87.             } 
88.         temp.currentDegree=biggerDegree; 
89.          
90.         return temp; 
91.          
92.     } 
93.  
94. polynomial operator -( const polynomial& one,const polynomial& two ) 
95.     { 
96.         polynomial temp; 
97.          
98.         int biggerDegree=( one.currentDegree > two.currentDegree ?one.currentDegree:two.currentDegree ); 
99.         for( int i=0;i<biggerDegree+1;++i ) 
100.             { 
101.                 temp.coefficient[ i ] = one.coefficient[ i ]-two.coefficient[ i ]; 
102.                  
103.             } 
104.         temp.currentDegree=biggerDegree; 
105.          
106.         return temp; 
107.          
108.     } 

 

1. /* 
2. * test.cpp 
3. */ 
4. #include <iostream> 
5. #include "polynomial.h" 
6.  
7. int main(  ) 
8.     { 
9.         float one[  ]={1,2,3,4,5}; 
10.         polynomial poly_one( one,5 ); 
11.         poly_one.display(  ); 
12.         std::cout<< poly_one.value( 1.0 )<<"\n"; 
13.  
14.         float two[  ]={1.2,2.5,-3.5,4.5,-5.5}; 
15.         polynomial poly_two( two,5 ); 
16.         poly_two.display(  ); 
17.         std::cout<< poly_two.value( 1.0 )<<"\n"; 
18.  
19.         polynomial poly_three; 
20.         poly_three=poly_two; 
21.         poly_three.display(  ); 
22.  
23.         polynomial poly_four(poly_two); 
24.         poly_four.display(  ); 
25.          
26.          
27.         return 0; 
28.          
29.     } 
30. /* 
31. * test.cpp 
32. */ 
33. #include <iostream> 
34. #include "polynomial.h" 
35.  
36. int main(  ) 
37.     { 
38.         float one[  ]={1,2,3,4,5}; 
39.         polynomial poly_one( one,5 ); 
40.         poly_one.display(  ); 
41.         std::cout<< poly_one.value( 1.0 )<<"\n"; 
42.  
43.         float two[  ]={1.2,2.5,-3.5,4.5,-5.5}; 
44.         polynomial poly_two( two,5 ); 
45.         poly_two.display(  ); 
46.         std::cout<< poly_two.value( 1.0 )<<"\n"; 
47.  
48.         polynomial poly_three; 
49.         poly_three=poly_two; 
50.         poly_three.display(  ); 
51.  
52.         polynomial poly_four(poly_two); 
53.         poly_four.display(  ); 
54.          
55.          
56.         return 0; 
57.          
58.     } 

从main中，poly_three和poly_four可知，如果我们没有声明复制构造函数和赋值构造函数的化，编译器会为我们自动添加。

另外，如果我们没有定义类的默认构造函数的话，编译器会为我们添加一个函数体为空的默认构造函数。

还有就是operator =()函数也会被自动添加，但是只满足同类对象之间相互赋值。

转载于:https://blog.51cto.com/liuguangtao/537704