初识C++

目录

1、命名空间（namespace）

1.1、namespace关键字

1.2、命名空间的使用

2. 输入输出（I/O）

3、缺省参数

4、函数重载

5、引用

5.1、引用特性

5.2、常引用

5.3、使用场景

5.3.1、引用做函数参数

5.3.2、引用做返回值

5.4、引用和指针的区别

6、内联函数（inline）

7、auto关键字（C++11）

8、基于范围的for循环(C++11)

---

1、命名空间（namespace）

在c/c++中，函数、变量都是大量存在的，这些存储在全局作用域中的函数和变量，可能会因为重定义频繁导致访问冲突。而命名空间是一种将标识符（如变量名、函数名、类名等）封装在一起的机制，用于避免命名冲突。

1.1、namespace关键字

命名空间定义：

// lsg是命名空间的名字
namespace lsg
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int left, int right)
    {
        return left + right;
    }//注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
}

1. 命名空间可以嵌套。
2. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
3. 一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

---

1.2、命名空间的使用

1、指定访问命名空间域

namespace lsg
{
	int a = 10;
}

int main()
{
	printf("%d\n", lsg::a);//用lsg::指定访问命名空间域

	return 0;
}

2、展开整个命名空间域

namespace lsg
{
	int a = 10;
}

using namespace lsg;//使用using展开命名空间域

int main()
{
	printf("%d\n", a);

	return 0;
}

3、使用using将命名空间中某个成员引入,展开一部分

namespace lsg
{
	int a = 10;
    int b = 20;
}

using lsg::b;

int main()
{
	printf("%d\n", b);

	return 0;
}

不过，尽量避免在全局作用域中使用using namespace，因为它可能会导致命名冲突。

---

2. 输入输出（I/O）

C++的输入输出主要通过标准库<iostream>实现，使用cin和cout。

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;//不过不建议直接展开std
int main()
{
    cout<<"Hello world!"<<endl;
    return 0;
}

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。

2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。

3. <<是流插入运算符，>>是流提取运算符。

std::cout（输出）和std::cin（输入）

#include <iostream>
int main() 
{
    int num;

    std::cin >> num;  // 从标准输入读取一个整数
    std::cout << num << std::endl;//打印输入的值
    return 0;
}

---

3、缺省参数

定义：缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

语法：

void func(int a = 20, int b = 10);  //全缺省参数

void func(int a, int b = 10);  // b是缺省参数（半缺省），默认值为10

比如：

void Func(int a = 0)
{
    cout<<a<<endl;
}
int main()
{
    Func();     // 没有传参时，使用参数的默认值
    Func(10);   // 传参时，使用指定的实参
 
    return 0;
}

注：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量

---

4、函数重载

函数重载：C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

比如：

#include<iostream>
using namespace std;

int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}
double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}

int main()
{
    Add(10, 20);
    Add(10.1, 20.2);
 
    return 0;
}

重载规则：

• 函数名必须相同。

• 参数类型或参数个数必须不同。

• 返回值类型不参与重载。

---

5、引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空 间，它和它引用的变量共用同一块内存空间。

语法：

int a = 10;
int& b = a;  // b是a的引用

5.1、引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
   int a = 10;
   // int& ra;   // 该语句编译时会出错
   int& ra = a;
   int& rra = a;
   printf("%p %p %p\n", &a, &ra, &rra);  
}

5.2、常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

5.3、使用场景

5.3.1、引用做函数参数

void Swap(int& left, int& right)
{
   int temp = left;
   left = right;
   right = temp;
}

5.3.2、引用做返回值

int& Count()
{
   static int n = 0;
   n++;

   return n;
}

5.4、引用和指针的区别

在概念上引用是别名，没有独立空间，和其引用实体公用同一块空间。但在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何 一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

---

6、内联函数（inline）

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开（将函数调用替换为函数体），没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

比如：

#include <iostream>

inline int add(int a, int b) 
{
    return a + b;
}

int main() 
{
    std::cout << add(5, 3) << std::endl;  // 输出8
    return 0;
}

注：

• inline适合短小的频繁调用的函数。
• inline对于编译器仅仅只是一个建议，最终能否成为inline，编译器自己决定，像比较长的函数、递归函数就算加了inline也会被否决掉。
• 默认debug模式下，inline不会起作用，否则不方便调试了。
• inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

---

7、auto关键字（C++11）

auto关键字用于让编译器自动推导变量的类型。

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

2. 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto()
{
    auto a = 1, b = 2; 
    auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

注：

• auto不能做函数的参数。
• auto不能直接用来声明数组

---

8、基于范围的for循环(C++11)

语法：

for (declaration : expression) 
{
    // 循环体
}

• declaration 是一个变量声明，用于定义循环中用于引用表达式中元素的变量。

• expression 是一个可迭代对象，如数组、容器（如 std::vector、std::list 等）、字符串等。

比如：

int array[] = {1, 2, 3, 4, 5};
for (int num : array) 
{
    std::cout << num << " ";
}
// 遍历输出数组元素

#include<iostream>
using namespace std;

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (auto& e : array) //e是数组元素的引用
		e *= 2;           //对e修改就是对数组元素的修改

	for (auto e : array)  //遍历修改后的数组
		cout << e << " "; //2 4 6 8 10

	return;
}

int main()
{
	TestFor();

	return 0;
}