浅淡 C++ 与 C++ 入门

        我们知道，C语言是结构化和模块化的语言，适用于较小规模的程序。而当解决复杂问题，需要高度抽象和建模时，C语言则不合适，而C++正是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式。

        因此在这篇博客，将会介绍C++中引入哪些新东西以及相对于C语言优化的地方。主要包括C++关键字/命名空间/C++输入输出/缺省参数/函数重载/引用/内联函数/基于范围的for循环。

1. 第一个 C++ 程序 

我们首先看代码和运行结果：

#include<iostream>
using namespace std;
 
int main()
{
	cout << "hello world"<<endl;
	return 0;
}

我们首先来看，这里打印 "hello world" 并没有利用C语言中使用的 printf 函数,这里使用的是 cout<< ,为此我们首先解释cout<<的含义。

cout 是控制台标准输出对象，使用时需要包含 头文件，而 << 流插入运算符，endl 是特殊的 C++ 符号，表示换行。与 cout<< 相对应的就是 cin>> ,我们来看代码：

#include<iostream>
using namespace std;
 
int main()
{
	int a = 0;
	cin >> a;
	cout << a << endl;
 
	return 0;
}

我们发现 cin>> 的功能就相当于C语言的 scanf, >> 是流提取运算符，同时我们可以看到cout<< 可以自动识别输出类型 。以上介绍的便是C++的 IO 流，包含流提取和流插入。 

那么 using namespace std; 这句代码是什么含义呢？为此我们首先要理解什么是命名空间。先看这样一个问题：下面的代码会报出命名冲突的问题，因为 rand 在C语言中是函数名。无法再次使用。而在C/C++中，变量、函数、类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。namespace 关键字的出现就是针对这种问题的。使用命名空间的目的是对标识符的名称进行本地化， 以避免命名冲突或名字污染，

#include
#include
 
int rand = 10;
 
int main()
{
	printf("%d",rand);
	return 0;
}

接下来，我们来看命名空间的定义,定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对 {} 即可，{} 中即为命名空间的成员。同时，命名空间可以嵌套。需要注意的是一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

namespace edsinty
{
    //在命名空间里定义
	int a = 10;
	int b = 100;
    //命名空间内部可以定义任何内容  
}

 命名空间有三种使用方式：

using namespace std;
 
int main()
{	
	cout << edsinty::a << endl;
	cout << edsinty::b << endl;
 
	return 0;
}
//加命名空间名称及作用域限定符
//edsinty::a

using namespace std;
using  edsinty::a;
 
int main()
{	
	cout << a << endl;
	cout << edsinty::b << endl;
 
	return 0;
}
//使用using将命名空间中某个成员引入
//using  edsinty::a;

using namespace std;
using namespace edsinty;
 
int main()
{	
	cout << a << endl;
	cout << b << endl;
 
	return 0;
}
//使用using namespace 命名空间名称 引入

这样我们就明白了 using namespace std;的含义了，需要注意的是 C++语言只有一个命名空间std，C++定义的所有的类和对象都是 std 这个命名空间下的命名的且C++的标准库都是在 std 命名空间中定义的。

2. 缺省参数

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

void Func(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Func();
	Func(100); 
	return 0;
}

缺省参数分为全缺省和半缺省，半缺省参数必须从右往左依次来给出，不能间隔着给 ，缺省参数不能在函数声明和定义中同时出现 ，缺省值必须是常量或者全局变量 ，C语言不支持 (编译器不支持) 缺省参数。

//全缺省
void Func(int a = 10, int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }
 
//半缺省
void Func(int a, int b = 10, int c = 20)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }
 
//缺省参数不能在函数声明和定义中同时出现
//a.h
  void Func(int a = 10);
  
  // a.cpp
  void Func(int a = 20)
 {}
  // 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值。

3. 函数重载

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

// 1、参数类型不同
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;
}
 
// 2、参数个数不同
void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
 cout << "f(int a)" << endl;
}
 
// 3、参数类型顺序不同
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}
 
int main()
{
	Add(10, 20);
	Add(10.1, 20.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

C语言没办法支持重载，是因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。 

4. 引用

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

int main()
{
	int a = 10;
	int& ra = a;//<====定义引用类型
 
	cout << a << endl;
	cout << ra << endl;
	cout << &a << endl;
	cout << &ra << endl;
}

需要注意以下几点： 引用类型必须和引用实体是同种类型的，引用在定义时必须初始化，一个变量可以有多个引用，引用一旦引用一个实体，再不能引用其他实体。

同时引用可以做参数和做返回值：

//做参数
void Swap(int& left, int& right)
{
   int temp = left;
   left = right;
   right = temp;
}
 
//做返回值
int& Count()
{
   static int n = 0;
   n++;
   return n;
}
//如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
引用返回，如果已经还给系统了，则必须使用传值返回。

 引用与指针的区别：

1.引用概念上定义一个变量的别名，指针存储一个变量地址；

2.引用在定义时必须初始化，指针没有要求；

3.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何 一个同类型实体；

没有NULL引用，但有NULL指针；

4.没有NULL引用，但有NULL指针；引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；

5.有多级指针，但是没有多级引用；访问实体方式不同，指针需要显式解引用，引用编译器自己处理；

6.引用比指针使用起来相对更安全。

5.内联函数

C语言的宏虽然具有增强代码的复用性，提高性能的优点，但是宏不方便调试，代码可读性差，可维护性差，容易误用；且没有类型安全的检查 。因此在 C++ 中可以利用 const enum 来代替宏的常量定义。短小函数定义换用内联函数，那什么是内联函数呢？

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

inline int Add(int x, int y)
{
	return x + y;
}
 
int main()
{
	int ret = Add(1,2);
	cout << ret << endl;
	return 0;
}

inline 是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，

缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

inline 对于编译器而言只是一个建议，不同编译器关于 inline 实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用 inline 修饰，否则编译器会忽略 inline 特性。

7. 基于范围的for循环

使用时，for 循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

	int array[] = { 1, 2, 3, 4, 5 };
	for (auto x : array) 
	{
		cout << x << " ";
	}

与普通循环类似，可以用 continue 来结束本次循环，也可以用 break 来跳出整个循环。for 循环迭代的范围必须是确定的， 对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin 和 end 的方法，begin 和 end 就是 for 循环迭代的范围。