• C++ 语言学习 day01 （linux ）,基本输入输出错误输出函数，名字空间的含义，内联函数，缺省参数，引用 ，、new操作符

    1.介绍c++

    C++头文件风格
    c++ 老风格：以.h结尾 是c语言风格  stdio.h  （尽量不）
    c++的转换风格： 去掉.h 在文件名前加c 例如#include
    c++ 新风格 ：没有拓展名 直接文件名，#include

    2.c++ 的开发环境
    1.  visual studio  2018
    2. qt creator 5.3
    3. g++ 开发环境
         第一步.安装g++ ，sudo apt-get install g++
         第二步. 编写.cpp的代码
        第三步： g++ xxx.cpp -o abc

    3.基本输入输出
      1. 标准输出   cout
         格式： cout << "字符串"  << 变量 << 变量 << endl;
         注意： endl是换行，可以放中间和末尾
                    c++的输出是流的方式实现是（stream）
                    在定义对象时，系统会在内存中开辟一段缓存，用来存放输入输出流的数据，缓冲区满或者遇到endl后或者flush后才会输出。
                     需要头文件  #include
                     cout是一个变量（是输出流的对象）
       2.格式化输出   （不是重点）
           第一种方式： setf成员函数，cout的成员函数。
                          fmtflags    setf(fmtflags __fmtfl)   
                          作用： 对输出的内容做格式化处理
                          参数： __fmtfl 是需要格式化处理的状态
                          比如： ios_base::showbase    显示进制的前缀
                               
                          fmtflags    setf(fmtflags __fmtfl, fmtflags __mask)
                          作用：  对输出的内容做格式化处理
                          参数：   __fmtfl 是需要格式化处理的状态
                                        __mask 需要取消的状态位
                          案例：cout. setf(ios_base::hex,ios_base::basefield);
           
                           综合案例： 设置宽度 和设置对齐方式
                             cout.width(宽度)；
                            设置右对齐方式 (setf函数，需要使用两个参数的版本，第一个参数ios_base::right,第二个参数是 ios_base::adjustfield )

           第二种方式： cout的成员函数  例如 width( )
           第三种方式：setiosflags函数   ( 笔记的方式发给大家--自行学习)

    setiosflags 是包含在命名空间iomanip 中的C++ 操作符，该操作符的作用是执行由有参数指定。

    区域内的动作；

      3.标准输入
        关键字：cin
        格式： cin >> 变量1 >> 变量2 ； 
        注意： cin也是一个对象，暂时理解成结构体变量 
                   等价于 scanf 
                   不可以加字符串  endl
                   cin可以识别基本数据类型。int double float short long 
         输入两个整形，计算他们的模，输出。
     
      4.标准错误
       关键字：cerr
       格式：cerr << "字符串" << 变量 <     注意： cerr是没有缓冲的，数据会立马输出
                   一般是遇到错误，需要立马打印出来的场景
                  
      5.标准日志：
      关键字： clog
      格   式： clog << "字符串" << 变量 <   注   意： 有缓冲，和cout的使用一样
                    需要打印日志的时候需要

    代码：

    1. #include<iostream>
    2. #include<cstdio>
    3. using namespace std;
    4. int main()
    5. {
    6. 	int  c;
    7. 	cout<< "我的名字："<<"she001"<<endl<<"今年：18岁"<< endl;
    8. 	int x=0x123;
    9. 	//cout.setf(ios_base::hex,ios_base::basefield);//设置输出为十六进制
    10. 	//cout.setf(ios_base::oct,ios_base::basefield);//设置输出为八进制
    11. 	//cout.setf(ios_base::dec,ios_base::basefield);//设置输出为十进制
    12. 	//cout.setf(ios_base::showbase);//设置为标准输出，加上 0x 
    13. 	//cout<<"x="<<x<<endl;//标准输入
    14. 	
    15. 	//cout.width(10);//设置输出的数据　宽度为10
    16. 	//cout.setf(ios_base::right,ios_base::adjustfield);//设置右对齐
    17. 	//cout<<x<<endl;
    18.  
    19. 	///标准输入　展示理解为结构体变量
    20. 	//关键字：　cin
    21. 	//注意　: cin 也是一个对象
    22. 	//等价于scanf    
    23. 	//cin 可以识别基本数据类型　 int  double float  short long 
    24. 	//
    25. 	//
    26. 	//
    27. 	// 练习　输入两个变量　取膜
    28.  
    29. 	//int a,b;
    30. //	cin>>a>>b;
    31. //	int d= a%b;
    32. //	cout<<d<<endl;
    33. 	//
    34. 	
    35.  
    36.  
    37.  
    38. 	///标准错误
    39. 	//关键字：cerr
    40. 	//格式：cerr <<"字符串"<<"变量"<<endl;
    41. 	//无缓冲
    42. 	cerr<<"我的错误"<<x<<endl;
    43.  
    44.  
    45. 	//标准日志　
    46. 	//关键字　clog
    47. 	//格式 clog<< " 字符串"<<"变量"<<endl;
    48. 	//注意　：有缓冲 和cout 的使用一样　.
    49. 	//		打印的时侯需要
    50. 	
    51. 	//clog<<"casda"<<x<<endl;
    52.  
    53.  
    54. 	
    55. 	return 0;
    56. }

    4.名字空间
         1. 前奏： using namespace std；  名字空间std
          为什么要名字空间；    
             防止命名冲突，提供作用域。
             模块化编程，提高效率
          2.定义名字空间
             格式：namespace 名字空间名 { 定义变量； 定义函数；}；
             注意： 在同一个作用域内，不可以有相同的名字空间名
          3.名字空间可以使用的内容
             可以定义变量
             可以定义结构体
             可以定义常量
             可以定义函数
             可以定义名字空间
              可以定义枚举
           4.案例 
             namespace huaqing{
                  int danny = 12;
                 const long num = 20;
                 struct stu {  int age ;   };
                 void fun(int a)    {   std::cout << "fun函数"<             enum week {mon,tue};    
             }
         6.名字空间的使用
           全部引入： using namespace 名称；
           部分引入： using 名称::成员
           域 限 定  ： 名称::成员
            //全部引入：说明接下来的变量如果找不到就是在huaqing的作用域中的。
           using namespace huaqing;
           //部分引入：只是用stu中的y
           using  stu::y;
          int main(){
              x = 123;
              fun(y);
               stu::area(1,2);
              struct huaqing::stu danny = {123};
              cout << "age = " <       }
         7.名字空间嵌套
           格式： namespace 名字空间1
                     {
                                    namespace 名字空间2{ 代码}；
                     }
           使用：
                   第一种： using namespace 名字空间1；
                                 名字空间2::变量 = 123；
                                 变量 = 123；
                   第二种：using namespace 名字空间1:: 名字空间2
                                变量 = 234；  //属于名字空间2中的
                                名字空间1:: 变量
                    第三种：名字空间1::名字空间2::变量 = 123；

          8.名字空间别名
             格式：namespace 别名 = 名字空间名
             例如： namespace abc = huaqing::danny
                         using namespace abc;

    代码：

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //定义名字空间　需要　定义两个变量　int x,y  
    5. //写两个函数　．计算点x ，y 和的三角形的面积　　
    6. namespace huaqing
    7. {
    8. 	int danny =12;
    9. 	const long num=23;
    10. 	struct stu
    11. 	{
    12. 		int age;
    13.  
    14. 	
    15. 	};
    16. 	//定义函数　
    17. 	void fun(int a)
    18. 	{
    19. 		std::cout<<"fun函数"<<endl;
    20. 	}
    21. 	
    22. 	enum week//枚举
    23. 	{
    24. 		mon,
    25. 		tue
    26. 	};
    27. 	namespace hh
    28. 	{
    29. 		void ll()
    30. 		{
    31. 			cout<<"dasdasd"<<endl;
    32. 		}
    33. 	
    34. 	}
    35. };
    36.  
    37. namespace gw
    38. {
    39. 	int ss(int x,int y)
    40. 	{	
    41. 		int c=x*y/2;
    42. 		return c;
    43. 		
    44. 	}
    45.  
    46. };
    47.  
    48.  
    49. using namespace gw;//说明数据找不到，就到gw 里面去找
    50. int main()
    51. {
    52. 	int gg=ss(2,2);
    53. 	cout<<gg<<endl;
    54. 	huaqing::hh::ll();
    55. 	return 0;
    56. }

    5.内联函数
       1.作用： 在c语言中，函数调用开销。使用频繁的函数开销更大，c++提供了内联函数，直接把函数内容进行复制到调用位置。
              一般情况下内联是和类一起使用。
      2.关键字：inline  在函数前加一个inline 
      3.注意事项：内联函数中代码原则上不允许超过10行。（一般5行内代码）
                       内联函数不允许使用循环语句和switch语句
                       如果函数不满足以上要求，则编译器会忽略inline关键字。
       
    四、函数重载
         1.定义：在相同的作用域下，函数名相同参数列表不同。（有两个相同函数名的函数--不会冲突），重载必须是两个及以上的函数才构成。
        2.参数列表不一样：
            个数不一样；
            类型不一样；
            顺序不一样
         3.目的
               减少对用户调用的复杂性，调用一个函数实现不同的效果（前人种树后人乘凉）
               减少函数名的数量，避免名字空间的污染，有利于程序可读性。
               
       注意： 返回值类型不一样不构成重载。
                  如果参数列表相同会构成函数的重定义错误。
                  const函数和非const函数构成承载（后续讲）
        4.实现原理
            g++编译器在编译的时候会把相同的函数名进行内部改名。对用户不可见。
            改名规则： 在原本函数名前加_z3表示返回值
                              参数中如果是string ---->Ss
                                                   int-------->i
                                                  long -------> l
                                                 double------->d
                                                 char----------->c
                                                 float---------->f
                        如果有函数int fun(int a,long b,double c)编译后的函数名_z3funild
                        映射后的函数名 = 返回值+函数名+类型名首字母
           5.匹配方式
            1.精准匹配：参数列表完全匹配，不需要做任何转换。
             2.提升匹配：整形提升（short-->int  ,bool-->int, char--->int） 
                                浮点型（float--->double）
            3.标准转换匹配：
                              int--->double,   double--->int
                              long-->double    ,double--->long
                              int-->unsigned int;
            4.省略匹配 （...） 比如printf函数。
               后续会讲到操作符重载（超级重要）

    代码：

    1. #include<bits/stdc++.h>
    2. using namespace std;
    3.  
    4.  
    5. //内联函数
    6. //作用：在c 语言　函数调用开销，使用频繁的函数开销更大，　c++
    7. //提供了内联函数，直接把函数内容进行复制调用位置
    8. //一般情况下是和类一起使用
    9. //
    10. //关键字：inline  函数前面加入关键字
    11. //注意事项：内联函数中代码，原则上不允许超过5行（不允许使用循环语句）
    12. //如果函数不满足以上要求，则编译器会忽略　inline 关键字
    13. //
    14. inline int add1(int a,int b)//内联函数减少调用时间
    15. {
    16. 	return a+b;
    17. }
    18.  
    19.  
    20.  
    21.  
    22. //函数重载  
    23. //定义：在相同的作用域：　
    24. int add(int a,int b)
    25. {
    26. 	cout<<"int "<<endl;
    27. 	return a+b;
    28. }
    29.  
    30. int add(int a,int b,int c)
    31. {
    32. 	cout<<"int "<<endl;add
    33. 	return a+b+c;
    34. }
    35.  
    36. int add(int a,int b,int c,int d)
    37. {
    38. 	cout<<"int "<<endl;
    39. 	return a+b+c+d;
    40. }
    41.  
    42.  
    43. double add(double a,double b)
    44. {
    45. 	cout<<"double"<<endl;
    46. 	return a+b;
    47. }
    48.  
    49.  
    50.  
    51. int main(int argc,char* argv[])
    52. {
    53. 	//cout<<add(1,2)<<endl;
    54. 	//cout<<add(1.1,2.2)<<endl;
    55. 	
    56. 	if(argc==3)
    57. 	{
    58. 		int a=atoi(argv[1]);
    59. 		int b=atoi(argv[2]);
    60. 		cout<<add(a,b)<<endl;
    61. 	}
    62. 	if(argc==4)
    63. 	{
    64. 		int a=atoi(argv[1]);
    65. 		int b=atoi(argv[2]);
    66. 		int c=atoi(argv[3]);
    67. 		cout<<add(a,b,c)<<endl;
    68. 	}
    69. 	if(argc==5)
    70. 	{
    71. 		int a=atoi(argv[1]);
    72. 		int b=atoi(argv[2]);
    73. 		int c=atoi(argv[3]);
    74. 		int d=atoi(argv[4]);
    75. 		cout<<add(a,b,c,d)<<endl;
    76. 	}
    77.  
    78.  
    79. 	return 0;
    80. }

    6.缺省参数
       1.定义： 缺省参数也叫默认参数，当调用函数不传入参数时，会自动填充参数
       2.格式：返回值 函数名（类型 变量= 值，类型 变量 = 值）{}
       3.注意： 缺省可以做到部分缺省和全部缺省；
                 函数定义时缺省一定是从右往左缺省，不可以第一个参数缺省，第二个不缺省
                 只有自定义函数才能缺省，库函数没法缺省
                 传实参是从左向右缺省，但形参是从右向左缺省。
                 如果传入了实参，则形参的值就是实参的拷贝，如果没有传入参数，才会使用缺省参数。
                 实参个数必须大于或者等于无默认值的形参个数。不可以多于所有形参个数。
                当使用缺省参数时，需要考虑函数重载的二义性。编译器不知道调用哪一个函数。
         4.练习
        int add(int a,int b= 0,int c= 0,int d = 0){    return a + b + c + d;}
        5. extern "C" ”
          使用： 在函数返回值前 加extern "c" 表示按照c语言的规则编译
           格式：extern "C" void fun(int a);
                     extern "C" void fun(int a,int b);
           注意： 加上后c语言规则中没有函数重载，不会修改函数名。
                      注意 "C" 为大写字母
                      加上extern “c”后，c++的函数和语法都正常只用，只是不修改函数名。
           第二种定义方式： extern "c" {int fun(int x);    int add(int x,int y);}
            c++会默认定义 #define __cplusplus  ，用来判断是c文件还是c++文件
          案例：
                  extern "C"  int  add(int a, int b,int c){
                         cout << "a = " << a <                     return a+b+c;
               }

    代码：

    1. #include<bits/stdc++.h>
    2. using namespace std;
    3.  
    4.  
    5. int add(int a=0,int b=0,int c=0,int d=0)
    6. {
    7. 	return a+b+c+d;
    8. }
    9.  
    10. int main(int argc,char * argv[])
    11. {
    12. 	//cout<<add()<<endl;
    13. 	//cout<<add(1)<<endl;
    14. 	//cout<<add(1,1)<<endl;
    15. 	if(argc ==2)
    16. 	{
    17. 		int a=atoi(argv[1]);
    18. 		cout<<add(a)<<endl;
    19. 	}
    20. 	if(argc ==3)
    21. 	{
    22. 		int a=atoi(argv[1]);
    23. 		int b=atoi(argv[2]);
    24. 		cout<<add(a,b)<<endl;
    25. 	}
    26. 	if(argc ==4)
    27. 	{
    28. 		int a=atoi(argv[1]);
    29. 		int b=atoi(argv[2]);
    30. 		int c=atoi(argv[3]);
    31. 		cout<<add(a,b,c)<<endl;
    32. 	}
    33. 	if(argc ==5)
    34. 	{
    35. 		int a=atoi(argv[1]);
    36. 		int b=atoi(argv[2]);
    37. 		int c=atoi(argv[3]);
    38. 		int d=atoi(argv[4]);
    39. 		cout<<add(a,b,c,d)<<endl;
    40. 	}
    41. 	
    42. }

     7、引用  （面试题：引用和指针的区别）
           1.引用作用
              引用时取别名，可以给变量取别名，避免使用临时变量出现。
           2.定义
             引用：数据类型 & 别名 = 原名；
             指针定义： 数据类型 * 指针= &变量；
            注意：引用自己没有内存空间。
                     如果说原名修改，引用的值也修改了。
                     引用不允许修改，只可以引用一次。
                     函数传参的方式：值传递，指针传递，引用传递。
           案例：在函数中，使用引用，修改两个变量的值，形参实参都修改。
           3.函数参数可以设置成引用
              void fun(int& xx,int& yy)
           3.函数的返回值为引用
              int& fun(int xx)；
              注意：不可以返回局部变量的引用。
           4.引用和指针的区别
               第一个：引用的底层实现是指针（自学）
               第二个：指针可以修改指向，而引用不可以修改
               第三个：引用必须在初始化时进行赋值，而指针可以在使用时赋值
               第四个： 没有空引用，引用必须连接到一块合法的内存空间
               第五个：有指针的引用，没有引用的指针。int& *p = x是错误的。
               第六个：引用的原名释放后操作引用就会错误，指针指向的内存空间释放，操作指针也会错误。
            5.常引用
                定义常量： const int x = 110;  
                定义常引用： conset int& x = y;  x++;
                常引用表示不可以通过引用修改值，但可以通过原名修改值。
                 常引用一般用于 函数的参数

    代码：

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. void ddd(int & a,int & b)
    5. {
    6. 	a=1;
    7. 	b=1;
    8. 	
    9. }
    10.  
    11.  
    12.  
    13. int main()
    14. {
    15. 	int a=2;
    16. 	int b=2;
    17. 	ddd(a,b);
    18. 	cout<<"a="<<a<<endl<<"b="<<b<<endl;
    19. }

    8.new操作符（面试题：请讲new和malloc的区别）
         1.new操作符的作用
            c++利用new操作来开辟堆空间，和malloc相似。 也需要释放delete
          2.匹配
           new----delete  
           malloc---free  
         3.语法规则
            格式1： 类型 * 指针变量 = new 类型标志符；
            格式2： 类型 * 指针变量 = new 类型标志符(初始值)；
            格式3： 类型 * 指针变量 = new 类型标志符[内存单元个数]；


     

         代码：

    1. #include<iostream>
    2. using namespace std;
    3. int main()
    4. {
    5. 	//用new创建普通变量
    6. 	int* p = new int(10);
    7. 	//用new创建一维数组
    8. 	int* arr = new int[10];
    9. 	//用new创建二维数组
    10. 	int(*p1)[10] = new int[2][10];
    11. 	
    12.  
    13. 	//释放空间
    14. 	delete p;
    15. 	delete arr;
    16. 	delete p1;
    17. 	return 0;
    18. }


                

  • 相关阅读:
    jvm attach实现一种简单更新rancher上测试环境代码的方法
    深眸科技革新升级OCR技术，与AI视觉实现有效融合赋能各行业应用
    牛客网刷题 | BC104 翻转金字塔图案
    数据结构详细笔记——栈与队列
    OSPF高级配置——学习OSPF路由协议的高级应用
    vue中封装el-table表格
    Access实现进度条功能
    Yii2使用composer安装MongoDB扩展
    冰狐智能辅助相对autojs的优势
    c 理解创建多进程
  • 原文地址：https://blog.csdn.net/she666666/article/details/126473463