C++入门---基础语法
Posted L_add
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++入门---基础语法相关的知识，希望对你有一定的参考价值。
1.命名空间
在C/C++中，变量，函数和类都是大量存在的，这些变量、函数和类的名称都将存在于全局作用域中，可能会导致很多冲突，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
1.1命名冲突
#include <stdio.h>
int main()
{
//命名冲突
//C语言的库里有scanf 函数
//假设用scanf作为变量名
int scanf = 10;
scanf("%d", &scanf);
}
#include <stdio.h>
namespace std
{
int scanf = 10;
}
int main()
{
//C语言不能解决的冲突问题
//C++命名空间，名字隔离
printf("%x\\n", scanf);//打印的是地址
}
1.2命名空间的定义
namespace std//以N1为命名空间
{
int a;//可以定义变量
int add(int a, int b)//可以定义函数
{
return a + b;
}
}
定义命名空间格式：namespace +命名空间的名字+{}
{}中为命名空间的成员
1、命名空间可以嵌套
2、同一个工程中允许存在多个相同名称的命名空间，编译器最后会和成在同一个命名空间中
注意：一个命名空间定义了一个新的作用域，命名空间的所有内容局限于该命名空间中
//C++为了防止命名冲突，把自己库里面的东西都定义在std的空间命名中
1.3命名空间使用的三种方式
1.3.1加命名空间名称及作用域限定符
指定作用域
每个地方都需要指定，是最规范的方式
#include <iostream>
int main()
{
std::cout << "hello world" << std::endl;
return 0;
}
1.3.2使用using namespace 命名空间名称引入
把std整个展开，相当于库里面的东西都到全局域了-》看起来方便，
但是如果我们自己定义的东西与库冲突就没办法解决
#include <iostream>
using namespace std;
int main()
{
cout << "hello world" << endl;
return 0;
}
1.3.3使用using将命名空间成员引入
对库里面常用的展开
#include <iostream>
using std::cout;
using std::endl;
int main()
{
cout << "hello world" << endl;
return 0;
}
2.C++输入输出
#include <iostream>
#include <stdio.h>
//ostream 类型全局变量 cout
//istream 类型全局变量 cin
int main()
{
/*cout 输入
cin 输出
endl换行*/
//对比C语言：可以自动识别类型
int a = 10;
int *p = &a;
printf("%d,%p\\n", a, p);
std::cout << a << "," << p << std::endl;
int b;
std::cin >> b;
std::cout << b << std::endl;
}
3.缺省参数
3.1缺省参数的概念
概念：缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参
#include <iostream>
using namespace std;
void TestFunc(int a = 10)
{
cout << a << endl;
}
int main()
{
TestFunc();
TestFunc(3);
}
3.1缺省参数分类
3.1.1全缺省参数
void TestFunc(int a = 10, int b = 20; int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
3.1.2半缺省参数
void TestFunc(int a , int b = 20; int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
注意：
1、半缺省参数必须从右往左依次来给出，不能间隔
2、缺省参数不能在函数声明和定义中同时出现
//a.h
void TestFunc(int a = 10)
{
cout << a << endl;
}
//a.c
void TestFunc(int a = 20)
{
cout << a << endl;
}
//注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，
//编译器无法确定到底该用哪个缺省值
3、缺省值必须是常量或者全局变量
4、C语言不支持
4.函数重载
4.1函数重载的概念
函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数或类型或顺序）必须不同，常用来处理实现功能类似数据类型不同的问题。
int Add(int a, int b)
{}
double Add(double a, double b)
{}
double Add(int a, double b)
{}
long Add(long a, long b)
{}
double Add(int a, double b)
{}
int Add(int a, double b)
{}
//错误：虽然返回值类型相同
// 但是形参相同
4.2名字修饰
为什么C语言不支持函数重载？
在C/C++中，程序运行，需要经历四个阶段：预处理、编译、汇编、链接
int add(int a, int b)
{
return a + b;
}
double add(double a, double b)
{
return a + b;
}
C的函数修饰后名字不变。而C++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。
C语言没办法支持重载，因为同名函数没办法区分。
C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
另外我们也理解了，为什么函数重载要求参数不同而跟返回值没关系。
4.3 extern"C"
在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern"C"，意思是告诉编译器，将该函数按照C语言规则来编译。
extern "C"int add(int a, int b);
int main()
{
add(1, 2);
return 0;
}
5.引用
5.1引用概念
引用不是新定义一个变量，而是给已存在的变量取了一个别名（小名），编译器不会为引用变量开辟内存空间，它和它的引用变量共同用一块内存空间
类型&引用变量名（对象名）= 引用实体
int main()
{
int a = 10;
//b是a的引用（别名）
int& b = a;
return 0;
}
注意：引用类型必须和引用实体是同种类型的
5.2引用特性
1、引用在定义时必须初始化
2、一个变量可以有多个引用
3、一旦引用一个实体，再不能引用其他实体。
int main()
{
int a = 10;
int& b = a;
return 0;
}
5.3常引用
int main()
{
const int a = 10;//不可修改
//int& ra = a;//ra引用a属于权限放大，不行
//ra->可读可写 a->可读
const int& ra = a;
int b = 20;
int& rb = b;
const int& rrb = b;//rrb引用b属于权限缩小，可以
//rrb->可读 b->可读可写
}
int c = 10;
double d = 1.11;
d = c//隐式类型转换，c和d之间产生临时变量
//double& rc = c;//不行
const double& rrc = c;//可以
5.4引用场景
5.4.1做参数
void Swap(int& a, int&b)
{
int tmp = a;
a = b;
b = tmp;
}
输出型参数
5.4.2做返回值（特殊场景）
传值返回
int Add(int a, int b)//c是临时变量，具有常性，所以要加const
{
int c = a + b;
return c;
}
int main()
{
const int& ret = Add(1, 2);
return 0;
}
传引用返回
int& Add(int a, int b)//传引用返回
{
int c = a + b;
return c;
}
int main()
{
int ret = Add(1, 2);
return 0;
}
越界访问
int& Add(int a, int b)//传引用返回
{
int c = a + b;
return c;
}
int main()
{
int &ret = Add(1, 2);
Add(5, 6);
cout << ret << endl;//11
return 0;
}
注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统，则必须使用传值返回
int& Add(int a, int b)//c不在栈帧上，在静态区（静态区不销毁）
{
static int c = a + b;
return c;
}
int main()
{
int &ret = Add(1, 2);
Add(5, 6);
cout << ret << endl;//结果是3
return 0;
}
5.5传值，传引用效率比较
#include <time.h>
struct A
{
int a[100000];
};
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
A a;
//以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i<10000; ++i)
TestFunc1(a);
size_t end1= clock();
//以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i<10000; ++i)
TestFunc2(a);
size_t end2 = clock();
//分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
当参数和返回值是比较大的变量时，传引用传参和传引用做返回值还可以提高效率
只要符合条件尽量引用传参 传返回值–>避免一些深拷贝
引用和指针的区别
int main()
{
int a = 10;
//在语法上，给a的空间取了一个别名，没有新开空间
int& ra = a;
ra = 20;
//在语法上，这里定义个pa指针变量，开了4个字节（32位），存储a的地址
int* pa = &a;
*pa = 20;
return 0;
}
1.引用在定义时必须初始化，指针没要求
2.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3.没有NULL引用，但有NULL指针
4.在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5.引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6.有多级指针，但是没有多级引用
7.访问实体方式不同，指针需要显式解引用，引用编译器自己处理
8.引用比指针使用起来相对更安全
6.内联函数
6.1内联函数的概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率
void Swap(int& a, int& b)//建立栈帧
{
int c = a;
a = b;
b = c;
}
int main()
{
int x = 0;
int y = 1;
Swap(x,y);
return 0;
}
C语言为了避免小函数建立栈帧-》提供宏函数支持-》在预处理阶段展开，不需要建立栈帧
#define Add(x,y) ((x) + (y))//C语言宏函数
int main()
{
int x = 0;
int y = 1;
Swap(x,y);
return 0;
}
C++提供inline函数-》解决宏函数缺点
宏函数缺点：
1、不支持调试
2、宏函数语法复杂容易出错
3、没有类型安全的检查
宏函数优点：
1、增强代码的复用性。
2、提高性能。
inline int add(int x, int y)
{
return x + y;
}
int main()
{
int c = add(1, 2);
cout << c << endl;
return 0;
}
C++推荐频繁调用的小函数，定义成inline ,会在调用的地方展开，没有栈帧的开销
6.2特性
1、inline是以一种空间换时间的做法，省去调用函数额开销。代码很长或循环/递归的函数不推荐使用
2、inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体有循环/递归等，编译器优化时会忽略掉内联。
3、inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址了，链接会找不到。
C++有哪些技术代替宏？
1、常用定义 换用const
2、短小函数定义 换用内联函数。
7.auto关键字
7.1auto简介
在早期C/C++中auto的含义：使用auto修饰的变量，是具有自动存储器的局部变量。
C++11中，auto不再是一个存储类型指令符，而是作为一个新的类型指令符来指示编译器，auto声明的变量必须有编译器在编译时期推导而得。
int main()
{
int a = 10;
//int b = a;
auto b = a;
//类型声明成auto，可以根据a的类型自动推导b的类型
}
注意：
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
7.2auto的使用规则
1、auto与指针和引用结合起来使用
用auto声明指针类型时：auto和auto*没有区别
auto声明引用类型时：auto&
int main()
{
int x = 10;
auto a = &x;//int*
auto* b = &x;//int*
int& y = x;//y的类型是int
auto&c = y;//int
auto& d = x;//d是x的引用
cout << typeid(x).name() << endl;
cout << typeid(y).name() << endl;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
return 0;
}
2、在同一行定义多个变量
当在同一行定义多个变量时，这些变量必须是相同类型，否则会报错。因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
int main()
{
auto a = 1, b = 2;
auto c = 3, d = 4.4;//错误！
return 0;
}
7.3auto不能推到的场景
7.3.1 auto不能作为函数的参数
void Testauto(auto a){}
//编译器无法对a的实际类型进行推导
7.3.2 auto不能直接声明数组
void Testauto()
{
int a[] = { 1, 2, 3 };
auto b[] = { 6, 7, 8以上是关于C++入门---基础语法的主要内容，如果未能解决你的问题，请参考以下文章