devbox
数据结构灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++的基础语法知识_c++基本语法

作者：数据结构灵魂 | 2024-01-28 23:35:31

赞

踩

c++基本语法

目录

一、认识C++

1、如C语言、C++、C#、Python等语言，为什么会有这么多语言存在？

2、C++解决了什么问题？

3、什么是面向对象？

4、C++的特性有什么？

二、C++的基础语法

1、编译器

2、第一个C++工程

<1>头文件

<2>名字空间--->namespace关键字

<3>using 关键字：导入或使用

3、C++中的结构体

<1>C++中对一个结构体的描述

4、C++中的字符串类型string

三、C++中的bool变量、&取址运算符、const修饰符

1、C++中的bool变量

2、C++中&取址运算符

3、C++中const修饰符

四、内联函数、函数参数默认值、函数重载机制、引用

1.内联函数

内联函数总结：

2.函数参数默认值

3.函数重载机制

补充：

4.引用

<1>引用的语法定义

<2>引用的本质

<3>底层实现

<4>引用使用实例演示

五、C++中的动态开辟空间的方式

一、认识C++

1、如C语言、C++、C#、Python等语言，为什么会有这么多语言存在？

因为语言是一种工具，当一个问题，如果可以使用更简洁高效的工具去解决时，这个工具就会被人们所使用。所以针对不同的问题就产生了不同的语言。

2、C++解决了什么问题？

C++是一门面向过程与面向对象方面都比较完善的语言，同时又加入了泛型抽象思想的加持，使C++在面对开发超大型程序方面游刃有余。

3、什么是面向对象？

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的属性，行为。

4、C++的特性有什么？

面向对象就是高度实物抽象化、面向过程就是自顶向下的编程。

面向对象有三大特性：封装性，继承性和多态性。

二、C++的基础语法

1、编译器

C++使用g++编译器进行编译，g++向上兼容可以编译C程序。同时g++编译器对类型的检查比gcc要更加的严格。

2、第一个C++工程

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5.     cout<<"hello world"<<endl;
  6.     return 0;
  7. }

<1>头文件

C++中标准库中的头文件一般都不带.h，同时C++为了兼容C标准库，把C标准库中的文件也都引用了过来，在所有C标准库文件前加个c

<2>名字空间--->namespace关键字

  1. namespace + 名字空间标识符
  2. {
  3.     //这个名字空间就是一个作用域
  4.     //在这个作用域中去定义你的变量名，函数名，类名。
  5. }

<3>using 关键字：导入或使用

1）using + 作用域标识符：：指定的变量，函数，类名，指的是指定导入的意思。

  1. using std::cout;//后面的代码可以使用cout(若不导入则会出现报错)
  2. using std::endl;//后面的代码可以使用endl
  3. //使用::逐级访问
  4. 例：
  5. namespace A
  6. {
  7.     int a = 100;
  8.     void showInfo()
  9.     {
  10.         cout << "22071班同学，你好！！！" << endl;
  11.     }
  12.     //作用域也是可以有嵌套的，访问嵌套作用域时，使用::域名访问符逐级访问。
  13.     namespace C
  14.     {
  15.         int a = 3000;
  16.     }
  17. }
  18. int main()
  19. {
  20.     //使用::逐级访问
  21.     cout << A::C::a << endl;
  22.     使用::域名访问符逐级访问。
  23.     using A::C::a;
  24.     cout << a << endl;
  25.     return 0;
  26. }

2）using + namespace + 作用域标识符：全部导入。（作用域中的所有的变量，函数，类标识符全部导入到当前文件中）

using namespace std;//将std的作用域中的所有变量、函数、类标识符全部导入

3、C++中的结构体

<1>C++中对一个结构体的描述

  1. #include <iostream>
  2. using namespace std;
  3. class Stu
  4. {
  5. public:
  6.     string name;
  7.     int age;
  8.     void write_code()
  9.     {
  10.         cout << "正在努力的写代码" << endl;
  11.     }
  12. };
  13. int main()
  14. {
  15.     Stu stu = {"zhangsan",18};
  16.     cout << stu.name << endl;
  17.     cout << stu.age << endl;
  18.     stu.write_code();
  19.     return 0;
  20. }

总结：

1）C++中结构体struct是有封装性，默认访问权限是私有的。

2）C++中定义类的关键字class也是由struct衍生而来，只不过class访问权限默认为private私有的。而struct默认的是公有的public。

3）C++struct结构体在定义对象时无需再struct关键再修饰一次了。

4）C++中struct结构中的函数，就叫成员函数。非静态成员函数可以直接调用结构中的变量，非静态成员函数行参列表中有一个隐藏的this指针，所以可以调用类中的成员属性。

4、C++中的字符串类型string

<1>C++中的string相当于C语言中的字符指针或字符数组，相对于C语言更加灵活，不需要在考虑结束符\0，及字符长度越界的问题。

  1. int main()
  2. {
  3.     string name = "gaowanxi";//1.定义一个string 对象
  4.     string name2 = ",lisi";
  5.     cout << name + name2 << endl; //两个字符串的连接，返回值是一个新的字符串。
  6.     cout << (name += name2) << endl;
  7. }

三、C++中的bool变量、&取址运算符、const修饰符

1、C++中的bool变量

bool是一个类型。底层就是unsigned char 无符号字符整形。

占一个字节，只有两个值：true :真，1 false :假，0

  1. #include <iostream>
  2. using namespace std;
  3. int main()
  4. {
  5.     bool ok;//定义一个bool类型的变量ok
  6.     ok = true;
  7.     cout << sizeof (ok) << endl;//判断一个bool变量的大小
  8.     cout << ok << endl;//输出此时的ok
  9.     ok = false;
  10.     cout << ok << endl;
  11.     return 0;
  12. }

2、C++中&取址运算符

  1. #include <iostream>
  2. using namespace std;
  3. typedef void (*Pfun)();//
  4. struct Stu//struct的默认权限是public
  5. {
  6.     string name;
  7.     int age;
  8.     void showInfo()
  9.     {
  10.         cout << "姓名：" << name << ",年龄：" << age << endl;
  11.     }
  12. };
  13. void show()
  14. {
  15.     cout << "22071班同学，加油！！！！" << endl;
  16. }
  17. int main()
  18. {
  19.     int a = 10;
  20.     int* p = &a;
  21.     cout<<*p<<endl;//&取地址运算符和C语言中使用方法相同
  22.     int arr[3] = {1,2,3};
  23.     //在C++中严格类型匹配，如果不匹配直接报错。
  24.     int(* pa)[3] = &arr;//int(* pa)[3]要和int arr[3]严格类型匹配
  25.     cout<<(*pa)[0]<<(*pa)[1]<<(*pa)[2]<<endl;
  26.     //指向此函数地址的函数指针。
  27.     Pfun f = &show;
  28.     f();
  29.     Stu stu = {"zhangsan",18};
  30.     //成员函数指针定义的方式及获取成员函数指针的方式：返回值  （作用域：：*指针变量）（形参类型）= & + 作用域 ::成员函数名
  31.     //成员函数指针:返回值根据自己的需要定，作用域：：*指针变量<指针变量是自己取的名>(形参列表)
  32.     //获取成员函数指针:& + 作用域 ::成员函数名
  33.     void (Stu::*pfunc)() = &Stu::showInfo;
  34.     (stu.*pfunc)();
  35.     return 0;
  36. }

3、C++中const修饰符

  1. //在C++中const修饰变量的几种情况
  2. //1.const修饰的变量承接的是一个立即数（常量），那么这变量，编译器将会成其进行优化，优化成一个常量。
  3. const int max = 1024;
  4. //2.const修饰的变量+volatile则不会被编译器优化
  5. const int volatile a = 100;
  6. //3.const修饰的变量不可被修改，但是可以通过指针获取const修饰的变量的地址从而修改对应地址下的内容
  7. int* p = (int*)&a;
  8. *p  = 500;

四、内联函数、函数参数默认值、函数重载机制、引用

1.内联函数

<1>内联函数语法形式

  1. inline + 返回值 函数名(形参列表)
  2. {
  3.     //内联函数体...
  4. }
  5. 默认情况下，inline关键字是放在函数的定义处。

内联函数总结：

C++的内联函数：主要是要继承C中宏函数的高效运行效率，同时又想避免C中宏函数所出现的一些语言Bug。

C++内联函数inline关键字只是一个荐意的作用，是否进行内联，也要看具体函数代码是否精简。如果代码逻辑复杂，或者有循环，有耗时操作，有递归时，将自动停止内联。

在C++中，所有结构体，或类中的成员函数都将自动加上inline进行优化，如果成员函数是一个复杂，或有循环，或有递归时，也将停止该成员函数的内联。

内联函数是有代价的：因为其会在内嵌在主函数中的函数调用处，所以会造成最终可执行程序的代码膨胀的问题。

2.函数参数默认值

函数参数默认值可以理解为：当定义函数时，形参列表赋初值

  1. #include <iostream>
  2. using namespace std;
  3. //C++中关于函数参数默认值的赋值规则是：
  4. //从右往左依次赋默认值（入栈），不可以跳跃。
  5. //同时，如果使用分文件编程时：函数默认参数赋值可以只写在声明处，定义得无需再次进行赋值。
  6. int add(int a = 1, int b = 2, int c = 3)
  7. {
  8.     cout<<"a="<<a<<endl;
  9.     cout<<"b="<<b<<endl;
  10.     cout<<"c="<<c<<endl;
  11.     return a + b + c;
  12. }
  13. int main()
  14. {
  15.     cout << add(10,20,30) << endl;//函数形参入栈的顺序是从右往左依次入栈
  16.     cout << add(10,20) << endl;
  17.     cout << add(10) << endl;
  18.     cout << add() << endl;
  19.     return 0;
  20. }

意义：函数调用参数的灵活性。

3.函数重载机制

C++的一个项目中同一作用域下允许多个同名函数同时存在，但是不能完全相同，参数类型，个数，顺序不同，他们之间形成重载关系；若完全相同会报错。

且与返回值是没有关系。

函数重载给我们带来好处：函数调用的灵活性，同时一种静态多态。多态：函数的不同实现。

例：

  1. #include <iostream>
  2. using namespace std;
  3. //C++中的函数重载是发生在同一作用域下的。
  4. int add(int a, int b)
  5. {
  6.     return a + b;
  7. }
  8. int add(int a,int b, int c)
  9. {
  10.     return  a + b + c;
  11. }
  12. string add(string a, string b, string c)
  13. {
  14.     return a + b + c;
  15. }
  16. int main()
  17. {
  18.     cout << add(10,20) << endl;
  19.     cout << add(10,20,30) << endl;
  20.     cout << add("xxxxooo","hhhhyyy","gggttt");
  21.     return 0;
  22. }

补充：

当函数参数默认值与函数重载发生冲突时，一定注意函数调用的参数个数（避免两者之中的冲突时，择优而选）。

C++作用域： 全局作用域，局部作用域，命名空间作用域，类作用域（结构体作用域）

4.引用

C++的引用就是一种C中的升级版指针。

<1>引用的语法定义

类型& 引用变量 = 变量

<2>引用的本质

引用并没有开辟新的空间，而是已存在空间变量的别名。

所以他的作用在于函数传参及函数返回值时，可以避免值的拷贝。

<3>底层实现

int& b = a; //底层的实现：int* const b = &a;

<4>引用使用实例演示

  1. #include <iostream>
  2. using namespace std;
  3. void swap(int* a, int* b)
  4. {
  5.     int temp = *a;
  6.     *a = *b;
  7.     *b = temp;
  8. }
  9. void swap(int& a,int& b)
  10. {
  11.     int temp = a;
  12.     a = b;
  13.     b = temp;
  14. }
  15. int main()
  16. {
  17.     int a = 10;
  18.     int& b = a;  //底层的实现：int* const b = &a;
  19.                 //在C++中const修饰的变量必须赋初值。
  20.     //引用的语法：类型& 引用变量 = 变量。
  21.     cout << &b << endl;
  22.     cout << &a << endl;
  23.     int x = 20;
  24.     int y = 30;
  25.     swap(x,y);
  26.     cout << "x = " << x <<endl;
  27.     cout << "y = " << y << endl;
  28.     
  29.     swap(&x,&y);
  30.     cout << "x = " << x <<endl;
  31.     cout << "y = " << y << endl;
  32.     return 0;
  33. }

函数返回值永远不要返回一个局部变量的地址或引用。

五、C++中的动态开辟空间的方式

关键字new开辟空间。

关键字delete释放空间。

如果是使new在堆上连续开辟空间时，释放空间，则要使用delete[] 来释放空间。

例：

  1. #include <iostream>
  2. using namespace std;
  3. //自定义Stu类类型。
  4. struct Stu
  5. {
  6.     string name;
  7.     int age;
  8. };
  9.  
  10. int main()
  11. {
  12.     int* p = new int;
  13.     cout << *p << endl;
  14.  
  15.     int* p1 = new int(1000);
  16.     cout << *p1 << endl;
  17.  
  18.     int* p2 = new int[10]();
  19.     cout << p2[9] << endl;
  20.     //连续开辟空间，同时对元素下标0，1，2中的值进行初始化。
  21.     int* p3 = new int[10]{1,2,3};//C+11标准下才有这种方式。
  22.  
  23.     //针对于自定义的类类型，如果连续开辟多个空间，一定要使用delete[]来释放。
  24.     Stu* stu = new Stu();
  25.     //类型后加括号，代表开辟空间同时对结构体中的属性进行初始化。
  26.     Stu* stu1 = new Stu[10]();
  27.     delete stu;
  28.     delete[] stu1;
  29.     delete p;
  30.     delete p1;
  31.     delete []p2;
  32.     delete []p3;
  33.     return 0;
  34. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/42243
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号