初入C++

目录

1.命名空间

1.1加命名空间名称及作用域限定符（::）

1.2 使用using将命名空间中某个成员引入

1.3使用using namespace 命名空间名称引入

2.C++输入&输出

3.缺省参数

3.1 缺省参数概念

3.2缺省参数分类

3.2.1全缺省参数

3.2.1半缺省参数

4. 函数重载 

4.1 函数重载概念

4.2 C++支持函数重载的原理--名字修饰 

 5.引用

5.1 引用概念

 5.2 引用特性

5.3使用场景 

5.4 引用与指针的区别

6. 内联函数

6.1 概念

6.2 特性

6.3 与宏的相关知识

7.auto关键字(C++11) 

7.1auto简介

7.2 auto的使用细则

7.2.1 auto与指针和引用结合使用

7.2.2在同一行定义多个变量 

 7.3 auto不能推导的场景

7.3.1. auto不能作为函数的参数

7.3.2. auto不能直接用来声明数组

7.3.3.其他

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

9.指针空值nullptr(C++11) 

1.命名空间

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。 

1.1加命名空间名称及作用域限定符（::）

当使用::时，编译器会直接去命名空间域去搜索。

int main()
{
    printf("%d\n",N::a);
    return 0;
}

1.2 使用using将命名空间中某个成员引入

在项目里面一般只展开最常用的，如cout、endl。

using std::cout;
using std::endl;
int main()
{
	int i = 0;
	std::cin >> i;
 
	cout << "hello" << endl;
	cout << "world" << endl;
	return 0;
}

1.3使用using namespace 命名空间名称引入

using namespce N;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;    
}

2.C++输入&输出

#include <iostream>
using namespace std;
int main()
{
   int a;
   double b;
   char c;
     
   // 可以自动识别变量的类型
   cin>>a;
   cin>>b>>c;
     
   cout<<a<<endl;
   cout<<b<<" "<<c<<endl;
   return 0;
}

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

3.2缺省参数分类

3.2.1全缺省参数

void Func(int a = 10, int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

3.2.1半缺省参数

void Func(int a, int b = 10, int c = 20) 
{
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

注意： 

1. 半缺省参数必须 从右往左依次 来给出，不能间隔着给。

2. 缺省参数不能在函数声明和定义中同时出现，一般在声明中出现。

3. 缺省值必须是常量或者全局变。

4. 函数重载 

4.1 函数重载概念

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
// 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;
}

4.2 C++支持函数重载的原理--名字修饰 

 5.引用

5.1 引用概念

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

void main()
{
	int a = 10;
	int& ra = a;//<====定义引用类型
	printf("%p\n", &a);
	printf("%p\n", &ra);
}

 5.2 引用特性

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.3使用场景 

引用 1、做参数（a、输出型参数 b、对象比较大，减少拷贝，提高效率；这些效果，指针也可以，但是引用更方便。

引用：2、做返回值 (a、修改返回对象 b、减少拷贝提高效率)。

5.4 引用与指针的区别

6. 内联函数

6.1 概念

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

6.2 特性

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

用函数体替换函数调用 ，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运

行效率。

2。inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址

了，链接就会找不到。

6.3 与宏的相关知识

宏的优缺点：

优点：

1. 增强代码的复用性。

2. 提高性能。

缺点：

1. 不方便调试宏。（因为预编译阶段进行了替换）

2. 导致代码可读性差，可维护性差，容易误用。

3. 没有类型安全的检查

7.auto关键字(C++11) 

7.1auto简介

C++11 中，标准委员会赋予了 auto 全新的含义即： auto 不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器， auto 声明的变量必须由编译器在编译时期推导而得 。

int TestAuto()
{
return 10;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = TestAuto();
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
return 0;
}

7.2 auto的使用细则

7.2.1 auto与指针和引用结合使用

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

加 &。

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    *a = 20;
    *b = 30;
     c = 40;
    return 0;
}

7.2.2在同一行定义多个变量 

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译

器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量 。

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

 7.3 auto不能推导的场景

7.3.1. auto不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

7.3.2. auto不能直接用来声明数组

void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4，5，6};
}

7.3.3.其他

1. 为了避免与 C++98 中的 auto 发生混淆， C++11 只保留了 auto 作为类型指示符的用法。

2. auto 在实际中最常见的优势用法就是跟 C++11 提供的新式 for 循环，还有lambda表达式等进行配合使用。

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

对于一个 有范围的集合 而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11 中引入了基于范围的 for 循环。 for 循环后的括号由冒号 “ ： ” 分为两部分：第一部分是范 围内用于迭代的变量，第二部分则表示被迭代的范围 。

void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
     e *= 2;
for(auto e : array)
     cout << e << " ";
return 0;
}

 注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

9.指针空值nullptr(C++11) 

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

void f(int)
{
 cout<<"f(int)"<<endl;
}
void f(int*)
{
 cout<<"f(int*)"<<endl;
}
int main()
{
 f(0);
 f(NULL);
 f((int*)NULL);
 return 0;
}

在 C++98 中，字面常量 0 既可以是一个整形数字，也可以是无类型的指针 (void*) 常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。