C++入门

最新推荐文章于 2024-06-17 09:40:06 发布

Noone0^

最新推荐文章于 2024-06-17 09:40:06 发布

阅读量350

点赞数 1

分类专栏： C++

本文链接：https://blog.csdn.net/imp0128/article/details/89552521

版权

C++ 专栏收录该内容

32 篇文章 1 订阅

订阅专栏

1.C++中的关键字

关键字属于保留字，是整个语言范围内预先保留的标识符。每个C++关键字都有特殊的含义。经过预处理后，关键字从预处理记号中区别出来，剩下的标识符作为记号，用于声明对象、函数、类型、命名空间等。不能声明与关键字同名的标识符。
常用的C++关键字:
在这里插入图片描述

2.命名空间

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

2.1命名空间的定义

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

//普通的命名空间
namespace N1 //N1为命名空间的名称
{ 
     int a; 
     int add(int left,int right)
     {
         return left+hight;
     }
namespace N2
{ 
       int a;
       int b;
       int sub(int left,int right)
       {
           return left+right; 
       }
namespace N3//命名空间可以嵌套
{
       int Mu1(int left,int right)
       { 
           return left+right;
       }   
}
namespace N1
//同一个工程中允许存在多个相同名称的命名空间
//编译器最后会合成同一个命名空间
{
       int Mu1(int left,int right)
       {
       ruturn lefy+right;
}

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

2.2命名空间的使用

namespace N
{
 int a=1;
 int b=2;
 int Add(int left,int right)
     {
      return left+right;
     }
}

命名空间的三种使用方式：
①加命名空间名称及作用域限定符

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

②示用Using将命名空间成员引入

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

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

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

3.C++的输入和输出

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

C++使用cin和cout来输入个输出，在使用cout标准输出和cin便准输入时必须包含iostream头文件以及std标准命名空间。与C语言相比，C++的输入输出更方便，不需要增加数据格式控制。如%d,%c等。 C++的输出和输入是用“流”(stream)的方式实现的｡

#include<iostream>
using namespace std;
int main()
{
int a;
double b;
char c;
cin>>a;
cin>>b>>c;

cout<<a<<endl;
cout<<b<<"  "<<end;

return 0;
}

4.缺省参数

4.1概念

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

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

4.2缺省参数的分类

①全缺省参数

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

②半缺省参数

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

注意：
1.半缺省参数必须从右往左依次来给，不能隔着给。如void TestFunc(int a=20,int b,int c=30)，这样的写法是错误的。
2.缺省参数不能再函数声明和定义中同时出现。

//a.h
void TestFunc(int a=10)
//a.c
void TestFunc(int a=20)
//如果声明与定义位置同时出现，恰巧两个位置的值不同，那么编译器无法确定到底应该使用那个

5.函数重载

5.1概念

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

void Add(int left,int right)//参数为int类型的Add函数
{
return left+right;
}
void Add(double left,double right)//参数为double类型的Add函数
{
return left+right;
}
void Add(long left,long right)//参数为long类型的Add函数
{
return left+right;
}
int main()
{
Add(10,20);//函数重载
Add(10.0,20.0);
Add(10l,20l);
return 0;
}

5.2名字修饰(保证函数名在底层的全局唯一性)

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接

名字修饰是一种在编译过程中，将函数、变量的名称重新改编的机制，是编译器为了区分各个函数，将函数通过某种算法，重新修饰为一个全局唯一的名称。
C语言的名字修饰规则非常简单，只是在函数名字前面添加了下划线。比如，对于以下代码，在最后链接时就会出错：

int Add(int left, int right);
int main(){ 
Add(1, 2); 
return 0;
}

在这里插入图片描述
上述Add函数只给了声明没有给定义，因此在链接时就会报错：error LNK2019: 无法解析的外部符号_Add，该符号在函数_main中被引用，从报错结果中可以看到，C语言只是简单的在函数名前添加下划线。因此当工程中存在相同函数名的函数时，就会产生冲突。

由于C++要支持函数重载，命名空间等，使得其修饰规则比较复杂，不同编译器在底层的实现方式可能都有差异。

int Add(int left, int right);
double Add(double left, double right);
int main(){ 
Add(1, 2); 
Add(1.0, 2.0); 
return 0;
}

在vs下，对上述代码进行编译链接，最后编译器报错：
在这里插入图片描述

编译器实际在底层使用的不是Add名字，而是被重新修饰过的一个比较复杂的名字，被重新修饰后的名字中包含了：函数的名字以及参数类型。这就是为什么函数重载中几个同名函数要求其参数列表不同的原因。只要参数列表不同，编译器在编译时通过对函数名字进行重新修饰，将参数类型包含在最终的名字中，就可保证名字在底层的全局唯一性。

1.C语言中为什么不能支持函数重载？

因为C语言的名字修饰C语言只是简单的在函数名前添加下划线。因此当工程中存在相同函数名的函数时，就会产生冲突。

2.C++中函数重载底层是怎么处理的?

重新修饰成比较复杂的名字，被重新修饰后的名字中包含了：函数的名字以及参数类型。

5.3extern “C”

有时候在C++中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。

extern "C" int Add(int left, int right);
int main()
{    
Add(1,2);    
return 0;
}

6.引用

6.1概念

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

类型& 引用变量名(对象名) = 引用实体；

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

引用类型必须和引用实体是同一数据类型

6.2引用特征

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体（本质是指针常量类型* const 不能改变其指向）

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

6.3常引用

int main() {
	const int a = 10;
	//int& ra = a;错误，a为const int, 引用类型和引用实体类型不同
	const int& ra = a;
	//int& b=10;错误，引用本身需要合法空间
	const int& b = 10;//编译器自动转化:int temp=10;const int& b=temp
    double d = 12.34;
	//int& rd = d;错误 d为double类型，引用类型和引用实体类型不同
	const int& rd=d; //rd=12 编译器给了临时变量
	//int temp=d;const int& rd=temp;
	return 0;
}

6.4引用做函数参数和返回值

①做函数参数：让形参修饰实参

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

②做返回值:不能返回局部变量引用（局部变量在栈区，函数结束即释放）

int& TestRefReturn(int& a)
{   
   a += 10;   
   return a;
}

6.5引用和指针的区别

引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。但指针有自己独立的空间, 指针存放的是所指变量的地址。

引用和指针的不同点:

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

7.内联函数inline

7.1概念

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

inline 这个关键字只是我们对编译器的建议, 并不像其他关键字一样, 是死命令

7.2特点

inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

宏的优缺点？（#define）
优点：1.增强代码的复用性。2.提高性能。
缺点：1.不方便调试宏。（因为预编译阶段进行了替换）2.导致代码可读性差，可维护性差，容易误用。3.没有类型安全的检查。

其中内联函数是在编译时展开(或不处理为内联函数), 类函数宏在预处理阶段展开，我们可以用内联函数来代替类函数宏, 解决以上缺点。

8.auto关键字（C++11）

8.1简介

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

8.2auto的使用规则

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

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

①auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

#include<iostream>
using namespace std;
int main() 
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;//int*
    cout << typeid(b).name() << endl;//int*
    cout << typeid(c).name() << endl;//int
    *a=20;
    cout << x << endl;//20  
    *b = 30;
    cout << x << endl;//30
    c = 40;
    cout << x << endl;//40
    system("pause");
    return 0;
}

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

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

8.3auto不能推导的场景

①auto不能作为函数的参数

void Testauto(auto a)//错误
{}

②auto不能直接用来声明数组

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

③auto不能定义类的非静态成员变量
④实例化模板时不能使用auto作为模板参数

9.基于范围的for循环

9.1范围for的语法

for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环

int main()
{
	int a[] = {1,2,3,4,5,6,7,8,9};
	for (auto i : a) {
		cout << i << "  ";
	}
	cout << endl;//1 2 3 4 5 6 7 8 9
	system("pause");
	return 0;
}

范围for的使用条件:

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

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

void TestFor(int array[]) 
{
    for(auto& e : array)//错误！for的范围不确定
    cout<< e <<endl;
}

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

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

10.1 C++98中的指针空值

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

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*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦。

#include<iostream>
using namespace std;
void f(int) 
{
	cout << "f(int)" << endl;
}
void f(int*) 
{
	cout << "f(int*)" << endl;
}
int main() 
{
	f(0);//f(int)
	f(NULL);//f(int)
	f((int*)NULL);//f(int*)
	system("pause");
	return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于(NULL)被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，*如果要将其按照指针方式来使用，必须对其进行强转(void )0。

10.2 nullptr 与 nullptr_t

为了考虑兼容性，C++11并没有消除常量0的二义性，C++11给出了全新的nullptr表示空值指针。那么C++11为什么不在NULL的基础上进行扩展，这是因为NULL以前就是一个宏，而且不同的编译器厂商对于NULL的实现可能不太相同，而且直接扩展NULL，可能会影响以前旧的程序。因此：为了避免混淆，C++11提供了nullptr，即：nullptr代表一个指针空值常量。
nullptr是有类型的，其类型为nullptr_t，仅仅可以被隐式转化为指针类型，nullptr_t被定义在头文件中：

typedef decltype(nullptr) nullptr_t;

注意 :

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

Noone0^

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++入门

1.C++中的关键字关键字---->语句----->实现算法逻辑。2.命名空间在C++中变量和类都是大部分存在的，这些变量、函数和类的名称都存在与全局作用域中，可能会导致很多冲突，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。 namespace关键字的出现就是针对这种问题的。2.1命名空间的定义命名空间的定义，需要使用到namespace关键字，后...
复制链接

扫一扫

专栏目录