Go语言视频零基础入门到精通

admin

在上章17.C++-string字符串类(详解)学习了string类,发现可以通过[ ]重载操作符来访问每个字符。
比如:

1. string s="SAD";
3. for(int i=0,i< s.length();i++)
4. cout<<s[i]<<endl;

复制代码

&nbsp;
接下来,我们来自己写个[ ]重载操作符,来模拟string类

1. #include <iostream>
2. #include "string.h"
4. class string
5. {
6. private:
7.    char *str;
8.    int len;
10. public:
11.     string(const char *p=0)
12.     {
13.       if(p!=NULL)
14.       {
15.        len=strlen(p);
16.        str = new char[len];
17.        strcpy(str,p);
18.       }
19.       else
20.       {
21.         len=0;
22.         str = new char[1];
23.         str[0]="\0";
24.       }  
25.     }
26.     char& operator [](int i)
27.     {
28.     return str[i];
29.     }
31.     int length()
32.     {
33.      return len;
34.     }
35. };
37. int main()
38. {
39.        string s="SAD";
40.        for(int i=0;i< s.length();i++)
41.        std::cout << s[i] << std::endl;
43.        return 0;
44. }　

复制代码

运行打印:

1. S
2. A
3. D

复制代码

　
函数对象

函数对象是指该对象具备函数的行为
函数对象,是通过()调用操作符声明得到的,然后便能通过函数方式来调用该对象了.
()调用操作符可以定义不同参数的多个重载函数
()调用操作符只能通过类的成员函数重载(不能通过全局函数)
函数对象用于在工程中取代函数指针

比如,定义一个函数对象t:

1. class Test{
2. public:
3.       void operator () (void)  //通过()重载操作符,来使对象具备函数的行为
4.      {
5.               cout<<"hello"<<endl;
6.      }
7. };
9. int main()
10. {
11.        Test t;
12.        t();          //打印"hello"
13. }　

复制代码

&nbsp;
函数对象与普通函数区别
函数对象
可以封装自己的成员以及其它函数,所以能够更好的面向对象.
普通函数
往往只具备逻辑关系,并且没有固定的成员,因为普通函数一被调用完后,里面的内容便被摧毁了,除非使用全局变量,但是全局变量又不具备封装性.
接下来,我们来个普通函数和函数对象的示例,便知道两者的区别了.
需求如下:

通过一个函数,来获取斐波那契数列每项的值
每调用一次函数,便返回一个值
可以重复使用

普通函数实例:

1. #include <iostream>           
2. using namespace std;
4. int cnt0=0;
5. int cnt1=1;
7. void fib_set(int n)          //设置斐波那契数列为哪一项,使fib()能重复使用
8. {
9.      cnt0=0;
10.      cnt1=1;
11.      for(int i=0;i<n;i++)
12.      {
13.             int tmp=cnt1;
14.             cnt1=cnt0+cnt1;
15.             cnt0=tmp;
16.      }
17. }
19. int fib()              //计算出一项值
20. {
21.   int tmp=cnt1;
22.   cnt1=cnt0+cnt1;
23.   cnt0=tmp;
25.   return tmp;
26. }
28. int main()
29. {
30.   for(int i=0;i<5;i++)
31.   cout<<fib()<<endl;    //打印1~5项值
33.   fib_set(0);                  //从新设置项数位0
35.   for(int i=0;i<5;i++)
36.   cout<<fib()<<endl;    //再次打印1~5项值,使它能重复使用
38.   return 0;     
39. }　

复制代码

运行打印:

1. 1
2. 1
3. 2
4. 3
5. 5
6. 1
7. 1
8. 2
9. 3
10. 5

复制代码

从上面代码可以看到,通过普通函数实现的需求,还需要两个全局变量才行,这在大项目里,完全不可取的,若项目里,像这样的模块多的话,那得有多少个全局变量啊？并且这些全局变量能够随意被破坏,没有一点封装性.
&nbsp;
接下来,通过函数对象来完成这个需求:

1. #include <iostream>           
2. using namespace std;
4. class Fib{
5. private:
6.        int cnt0;
7.        int cnt1;
8. public:
9.        Fib(int n=0)
10.        {
11.           cnt0=0;
12.           cnt1=1;
13.        }
15.        void operator =(int n)
16.        {
17.           cnt0=0;
18.           cnt1=1;      
19.           for(int i=0;i<n;i++)
20.           {
21.              int tmp=cnt1;
22.              cnt1+=cnt0;
23.              cnt0=tmp;
24.           }
25.        }
27.        int operator () ()
28.        {
29.              int tmp=cnt1;
30.              cnt1+=cnt0;
31.              cnt0=tmp;
33.               return cnt0;
34.        }
36. };
38. int main()
39. {
40.   Fib  fib;
41.   for(int i=0;i<5;i++)
42.   cout<<fib()<<endl;    //打印1~5项值
44.   fib=0;                        //从新设置项数为0
46.   for(int i=0;i<5;i++)
47.   cout<<fib()<<endl;    //打印1~5项值
49.   return 0;     
50. }　

复制代码

运行打印:

1. 1
2. 1
3. 2
4. 3
5. 5
6. 1
7. 1
8. 2
9. 3
10. 5

复制代码

从上面代码看到,使用函数对象后,便不需要使用全局变量了.