• C++之STL前序


    这篇文章,主要是来大致说一下,我们在用c写算法的时候,因为要用到STL ,这个毕竟是C++的东西嘛,所以多少还是要了解c++的一些语言特性

    首先在linux上,编译c语言,一般采用的是gcc编译器,但是如果是cpp文件,我们用gcc就会报错

    比如在下面有一个文件demo1.cpp

    1. 1 #include
    2. 2
    3. 3 using namespace std;
    4. 4
    5. 5 int main()
    6. 6 {
    7. 7 cout << "hello,c++" << endl;
    8. 8 return 0;
    9. 9 }

    上面采用的就是纯c++来编写文件

    假如我们用gcc来编译cpp文件,会怎么样?

    基本上来说,就会报一些 未定义错误,因为毕竟很多东西找不到

    下面我们用g++来编译cpp文件

    上面基本上就运行成功

    但是这个代码还有一些问题,就是C++的流运行太慢,所以,一般我们还是采用c语言的方式进行输入欲输出,因此,就要引入c相关的头文件

    之前我们在c语言编程中,头文件引入一般是采用.h方式,比如stdio.h、stdlib.h等等,我们知道c++能编译大多数的c语言程序。可以直接引入c语言头文件,虽然c语言中大多数头文件在c++中依然可以使用,但是推荐的方法是在c头文件之前加一个小写的c字母,然后去掉.h后缀,比如变为

    上面的cpp就可以做如下修改

    1. 1 #include
    2. 2 #include
    3. 3
    4. 4 using namespace std;
    5. 5
    6. 6 int main()
    7. 7 {
    8. 8 printf("hello,c++");
    9. 9 return 0;
    10. 10 }

     运行结果:

     下面说一下c++当中的一些字符串处理

    先来说几个函数

    1.getline() 读取一行字符串

    这个就相当于是从I/O流当中读取字符串的,他是一个string类的一个全局函数,C++需要用#include 来引入这个头文件去包含这个函数

    2.stringstream类,这是一个c++中的输入输出操作流

    这个流可以帮助我们去截取一行中我们需要的部分内容,比如一行以空格隔开的整数字符串,就可以通过这个流截取出来

    需要注意一点的是这个流不可以通过c语言中的%s打印输出,因为他不是字符串,如果想变成字符串可以通过函数c_str(),这样就可以%s打印,毕竟%s只会打印char*的类型

    下面就涉及到一个问题,就是:输入数据的每行包含若干个以空格隔开的整数,我们需要输出每行中所有整数之和,并且只能采用字符与字符数组的方式

    如果采用c语言方式考虑,相对来说就会比较复杂,因为c语言没有直接对字符串进行比如分割的函数,同时数据输入也比较麻烦,利用fgets来输入,输入之后怎么从一个字符串中分离出整数,不好整,你如果用getchar(),也不好做,比如输入456,getchar只会去得到4

    下面采用c++流的方式来做                                                                                                                                                                                                                                                                             

    1. 1 #include
    2. 2 #include //这个里面包含了string类,getline()方法也在里面
    3. 3 #include
    4. 4
    5. 5 using namespace std;
    6. 6
    7. 7 int main()
    8. 8 {
    9. 9 string line;
    10. 10 //这个getline就是说从标准设备中输入,也就是说,从键盘中输入
    11. 11 while(getline(cin,line)) {
    12. 12 int sum = 0,x;
    13. 13 //定义一个字符串的输入输出流,然后用来分割出整数
    14. 14 //以空格为分割的整数
    15. 15 //这个实现原理就像是cin的输入,取决于遇到空格就停止
    16. 16 stringstream s(line);//这里用括号就是类似于构造函数赋值,基本类型都差不多
    17. 17 //这里就开始流式获取
    18. 18 while(s >> x){
    19. 19 sum += x;
    20. 20 }
    21. 21 cout << sum << "\n";
    22. 22 }
    23. 23 return 0;

    运行结果:

     

    说一下c++中的结构体

    我们之前在c语言里面定义结构体,经常要typedef来取一个别名,在c++里面就不用了,结构体名字可以直接拿来用。而且在结构体里面,除了有变量之外,还可以有函数。 

    这里直接上代码

    demo5.cpp

    1. #include
    2. using namespace std;
    3. //在c++把结构体当成类一样对待就行
    4. struct Point {
    5. int x,y;
    6. //相当于创建一个构造函数
    7. Point(int x=0,int y=0)
    8. {
    9. //这个this代表当前结构体对象的指针
    10. this->x = x;
    11. this->y = y;
    12. }
    13. };
    14. //这里是一个加号运算符重载,operator是系统起的名字
    15. //用这个名字方便后面对象直接相加,operator可以省略
    16. Point operator + (const Point& a,const Point& b)
    17. {
    18. return Point(a.x + b.x,a.y + b.y);
    19. }
    20. //这里做一个左移运算符重载
    21. //可以方便我们输出一个对象
    22. //这里返回的是一个输出流,也就是cout的输出流对象
    23. //返回这个对象的目的就是方便我们流式调用<<
    24. ostream& operator << (ostream &out,const Point& p)
    25. {
    26. cout << "[" << p.x << "," << p.y << "]";
    27. return cout;
    28. }
    29. int main()
    30. {
    31. Point a,b(1,2);//做了两个结构体对象,一个调用了空参构造,一个调用了无参构造
    32. //设置a对象中x等于30,未赋值默认初始化为0
    33. a.x = 3;//3 + 1,0+2
    34. cout << a+b << endl;//[4,2]
    35. return 0;
    36. }

    运行结果:

     下面简单说一下模板

      在说模板之前,先来看一个求数组和的函数

    1. 1 #include
    2. 2 #include
    3. 3
    4. 4 //这个函数目的就是求整数数组的和
    5. 5 int sum(int* begin,int* end)
    6. 6 {
    7. 7 int ans = 0;
    8. 8 for(int *p = begin;p != end;p++) {
    9. 9 ans += *p;
    10. 10 }
    11. 11 return ans;
    12. 12 }
    13. 13
    14. 14 int main()
    15. 15 {
    16. 16 int arr[] = {1,2,3,4};
    17. 17 int res = sum(arr,arr + 4);
    18. 18 printf("%d\n",res);
    19. 19 return 0;
    20. 20 }

     运行结果:

    上面这个程序其实存在一个问题,就是只能处理整数数组的和 

    下面我们设计个模板,格式如下

    1. 18 T sum1(T* begin,T* end)
    2. 19 {
    3. 20 T ans = 0;
    4. 21 for(T *p = begin;p != end;p++) {
    5. 22 ans += *p;
    6. 23 }
    7. 24 return ans;
    8. 25 }
    9. 26
    10. 27
    11. 28 int main()
    12. 29 {
    13. 30 int arr[] = {1,2,3,4};
    14. 31 int res = sum(arr,arr + 4);
    15. 32 double arr1[] = {1.1, 2.2, 3.3, 4.4};
    16. 33 double res1 = sum1(arr1,arr1 + 4);
    17. 34 printf("%lf\n",res1);
    18. 35 return 0;
    19. 36 }
    20. "demo6.cpp" 36L, 65

    运行结果:

     

    我们下面处理一个更复杂的结构体类型的数据呢,这个结构体就是上面我们做的Point类型的结构体

    1. #include
    2. using namespace std;
    3. //在c++把结构体当成类一样对待就行
    4. struct Point {
    5. int x,y;
    6. //相当于创建一个构造函数
    7. Point(int x=0,int y=0)
    8. {
    9. //这个this代表当前结构体对象的指针
    10. this->x = x;
    11. this->y = y;
    12. }
    13. };
    14. //这里是一个加号运算符重载,operator是系统起的名字
    15. //用这个名字方便后面对象直接相加,operator可以省略
    16. Point operator + (const Point& a,const Point& b)
    17. {
    18. return Point(a.x + b.x,a.y + b.y);
    19. }
    20. //这里做一个左移运算符重载
    21. //可以方便我们输出一个对象
    22. //这里返回的是一个输出流,也就是cout的输出流对象
    23. //返回这个对象的目的就是方便我们流式调用<<
    24. ostream& operator << (ostream &out,const Point& p)
    25. {
    26. cout << "[" << p.x << "," << p.y << "]";
    27. return cout;
    28. }
    29. //我们还可以利用泛型来处理Point结构体类型的数据
    30. template<typename T>
    31. T sum(T* begin,T* end)
    32. {
    33. T ans = 0;
    34. for(T *p = begin;p != end;p++) {
    35. //这里对加号做了一个运算符重载
    36. //所以累加只能用加号来处理
    37. ans = ans + *p;
    38. }
    39. return ans;
    40. }
    41. int main()
    42. {
    43. /*Point a,b(1,2);//做了两个结构体对象,一个调用了空参构造,一个调用了无参构造
    44. //设置a对象中x等于30,未赋值默认初始化为0
    45. a.x = 3;//3 + 1,0+2
    46. cout << a+b << endl;//[4,2]
    47. */
    48. Point b[] = {Point(1,2),Point(3,4)};
    49. cout << sum(b,b+2) << endl;
    50. return 0;
    51. }

     运行结果:

    然后我们发现一个问题就是,上面结构体参数中的x,y是int类型的,但如果我们需要double类型参数的结构体呢,我们去把源文件修改一下

    1. #include
    2. using namespace std;
    3. //c++把结构体当成类一样对待就行
    4. //把它做成一个泛型模板
    5. template<typename T>
    6. struct Point {
    7. T x,y;
    8. //相当于创建一个构造函数
    9. Point(T x=0,T y=0)
    10. {
    11. //这个this代表当前结构体对象的指针
    12. this->x = x;
    13. this->y = y;
    14. }
    15. };
    16. //这里是一个加号运算符重载,operator是系统起的名字
    17. //用这个名字方便后面对象直接相加,operator可以省略
    18. //这里也做成模板
    19. template<typename T>
    20. Point operator + (const Point& a,const Point& b)
    21. {
    22. return Point(a.x + b.x,a.y + b.y);
    23. }
    24. //这里做一个左移运算符重载
    25. //可以方便我们输出一个对象
    26. //这里返回的是一个输出流,也就是cout的输出流对象
    27. //返回这个对象的目的就是方便我们流式调用<<
    28. template<typename T>
    29. ostream& operator << (ostream &out,const Point& p)
    30. {
    31. cout << "[" << p.x << "," << p.y << "]";
    32. return cout;
    33. }
    34. //我们还可以利用泛型来处理Point结构体类型的数据
    35. template<typename T>
    36. T sum(T* begin,T* end)
    37. {
    38. T ans = 0;
    39. for(T *p = begin;p != end;p++) {
    40. //这里对加号做了一个运算符重载
    41. //所以累加只能用加号来处理
    42. ans = ans + *p;
    43. }
    44. return ans;
    45. }
    46. int main()
    47. {
    48. /*Point a,b(1,2);//做了两个结构体对象,一个调用了空参构造,一个调用了无参构造
    49. //设置a对象中x等于30,未赋值默认初始化为0
    50. a.x = 3;//3 + 1,0+2
    51. cout << a+b << endl;//[4,2]
    52. */
    53. /*
    54. //这里做的是一个整型处理
    55. Point b[] = {Point(1,2),Point(3,4)};
    56. cout << sum(b,b+2) << endl;
    57. */
    58. //下面说一下point结构体存储浮点
    59. Point<double> d1(1.1,2.2),d2(3.3,4.4);
    60. //cout与加号运算符
    61. cout << d1 + d2 << "\n";
    62. return 0;
    63. }

    运行结果:

     基本上也就是这些,后面想到了再添加。

    祝早安,午安,晚安。

     

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

  • 相关阅读:
    Kyligence Cloud 集成 Amazon Glue 实现数据目录统一管理
    Kali linux 下配置社会工程学工具包SET
    使用Langchain+GPT+向量数据库chromadb 来创建文档对话机器人
    python编程:SQLite 管理图片数据库
    在页面中使用store中的成员
    ttkefu子账号提示已被关闭或过期是什么一样,该怎么处理呢?
    运营-20.产品社区化和内容化
    Read Uncommitted
    全球地下水水位数据
    操作表单(验证)
  • 原文地址:https://blog.csdn.net/Pxx520Tangtian/article/details/126783371