C++入门

凡人多烦事~

已于 2024-04-12 16:12:04 修改

阅读量859

点赞数 21

分类专栏： C++ 文章标签： c++ 开发语言 c语言

于 2024-03-27 21:59:06 首次发布

本文链接：https://blog.csdn.net/weixin_52550678/article/details/136608601

版权

C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1. C++关键字

C++总计63个关键字，C语言32个关键字

在这里插入图片描述

2. 命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就时针对这种问题的。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<stdlib.h>

//全局变量
int rand = 10;

int main()
{
	//编译后报错，rand重定义以前定义的是函数
	printf("%d", rand);
	return 0;
}

由于C语言无法解决这样的命名冲突问题，所以C++提出了namespace来解决

命名空间定义

定义命名空间，需要使用namespace关键字，后面跟 命名空间的名字然后接一对{} 即可 ，{}中即为命名空间的成员

1.正常的命名空间定义

// 命名空间中可以定义变量/函数/类型
namespace ma
{
	int rand = 10;
	int Add(int left, int right)
	{
		return left + right;
	}
}

2.命名空间可以嵌套

namespace m1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace m2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

3.同一个工程中允许存在多个相同名称的命名空间

最终编译器会合成一个命名空间中

一个工程中的test.h和上述的test.cpp中的两个m1会被合并成一个

#define _CRT_SECURE_NO_WARNINGS 1

namespace m1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

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

命名空间使用

当直接进行使用时，会报错


namespace m1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
}

int main()
{
	printf("%d\n", a);// “a”: 未声明的标识符
	return 0;
}

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

加命名空间及作用域限定符

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

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

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

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

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

using namespace m1
编译默认查找
a、当前局部域
b、全局域找
c、到展开的命名空间中找

3. C++输入&输出


#include <iostream>

//std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;

int main()
{
	cout << "Hello World!!!" << endl;
	return 0;
}

说明：

使用cout标准输出对象（控制台）和cin标准输入对象（键盘时），必须包含 < iostream > 头文件以及按命名空间使用方法使用std
cout和cin是全局的流对象，endl使特殊的C++符号，表示换行输出，他们都包含在< iostream >头文件中
<<使流插入运算符，>>是流提取运算符
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型
实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识

自动识别变量类型

#include<iostream>
using namespace std;

int main()
{
	int a;
	double b;
	char c;

	//可以自动识别变量的类型
	cin >> a;
	cin >> b;
	cin >> c;

	cout << a << endl;
	cout << b << " " << c << endl;
	return 0;
}

std命名空间的使用惯例：
std使C++标准库的命名空间，如何展开std使用更合理呢？

在日常练习中，可以直接using namespace std即可，这样比较方便
using namespace std展开，标准库全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。在项目开发中使用时，像std::cout这样使用时指定命名空间+using std::cout展开常用的的库对象/类型等方式。

4. 缺省参数

缺省参数概念

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

#include<iostream>
using namespace std;
void Func(int a = 10)
{
	cout << a << endl;
}
int main()
{
	Func();//没有传参时，使用参数的默认值
	Func(2);//传参时，使用指定的实参
}

缺省参数分类

全缺省参数
半缺省参数

#include<iostream>
using namespace std;
void Func(int a = 10,int b=20,int c=30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
int main()
{
	Func();//全缺省参数，使用参数的默认值
	Func(1,2);/半缺省参数
}

在这里插入图片描述

  //test.h
  void Func(int a = 10);
  
  // test.cpp
  void Func(int a = 20)
 {}
  
  // 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值

注意：

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

5. 函数重载

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

1.参数类型不同

#include <iostream>
using namespace std;

int Add(int left, int right)
{
	cout << "int Add(int left, int rught)" << 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, 10.2);
}

2.参数个数不同

#include <iostream>
using namespace std;

void f()
{
	cout << "f()" << endl;
}

void f(int a)
{
	cout << "f(int a)" << endl;
}

int main()
{
	f();
	f(2);
}

3.参数类型顺序不同

#include <iostream>
using namespace std;

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()
{
	f(2, 'a');
	f('a', 2);
}

6. 引用

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

类型& 引用变量名（对象名）= 引用实体

void Test()
{
	int a = 10;
	int& re = a;//定义引用类型

	printf("%d ", &a);
	printf("%d", &re);
}

注意：引用类型必须和引用实体的同种类型的

引用特性

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

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

常引用

#include <iostream>
using namespace std;

void Test()
{
	const int a = 10;
	//int& re = a;//该语句编译时会报错，a为常量
	const int& ra = a;

	//int& b = 20;//该语句编译时会报错，b为常量
	const int& b = 20;

	double c = 3.14;
	//int& cd = d;//该语句编译时会报错，类型不同
	const int& cd = c;

}

使用场景

1.做参数

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

2.做返回值

int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}

传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大的，效率就更低。

struct A{ int a[10000]; };
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;
}

7. auto关键字

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

类型难于拼写
含义不明确导致容易出错

#include <iostream>
using namespace std;
#include <string>
#include <map>

int main()
{
	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange","橙子" },{ "pear","梨" } };
	std::map<std::string, std::string>::iterator it = m.begin();

	while (it != m.end())
	{
		//....
	}
	return 0;
}

std::map<std::string, std::string>::iterator 是一个类型，但是该类型太长了特别容易写错

auto简介

在早期C/C++中的auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但是一直未被使用过。

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

#include <iostream>
using namespace std;
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;

	return 0;
}

注意
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明声明时的“占位符”编译器在编译期会将auto替换为变量实际的类型。

auto的使用规则

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;
}

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

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

auto不能推导的场景

auto不能作为函数的参数

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

auto不能直接用来声明数组

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

为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
auto在实际中最常见的优势用法就是跟新式for循环，还有lambda表达式等进行配合使用

8. 基于范围的for循环

范围for的语法

void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
     array[i] *= 2;
for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
     cout << *p << endl; }

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此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; }

范围for的使用条件

for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

注意：以下代码就有问题，因为for的范围不确定

void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl; }

迭代的对象要实现++和==的操作

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

C++98中的指针空值

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void TestPtr()
{
int* p1 = NULL;
int* p2 = 0;
// ……
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

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

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void)的常量*。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

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; }

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。

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

注意：

在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入
在C++11中，sizeof(nullptr) 与 sizeof((void)0)所占的字节数相同。*
为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。