C++基础入门

最新推荐文章于 2023-03-17 08:00:00 发布

一零二四bit

最新推荐文章于 2023-03-17 08:00:00 发布

阅读量112

点赞数

分类专栏： C++初阶文章标签： C++ 知识点整理

本文链接：https://blog.csdn.net/qq_41906009/article/details/102693495

版权

C++初阶专栏收录该内容

8 篇文章 0 订阅

订阅专栏

知识点

● 命名空间
● C++输入&输出
● 缺省参数
● 函数重载
● 引用
● 内联函数
● auto关键字(C++11)
● 基于范围的for循环(C++11)
● 指针空值—nullptr(C++11）

1.命名空间----一个新的作用域，作用：解决名字冲突。

(普通命名空间，命名空间可嵌套，相同名字的命名空间)

● 命名空间里即可以放变量也可以放函数，不是一个类型，而是一个作用域；
● 不同作用域中的同一名字不会冲突，命名空间可以嵌套；
● 同一个工程中允许存在多个相同名称的命名空间，编译器后会合成同一个命名空间中。

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

2.C++输入和输出：
cin>>接受变量>>接受变量
cout<<输出内容<<输出内容<<endl;
“\n”

3.缺省参数：

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

全缺省参数

void TestFunc1(int a = 1,int b=2,int c=3)
{
    cout << a <<" "<< b <<" "<< c <<endl;
}

半缺省参数：部分参数带有缺省值

void TestFunc2(int a , int b = 2, int c=3)
{
    cout << a << " " << b << " " << c <<endl;
}
int main()
{
    TestFunc1();
    TestFunc1(10,20,30);
    TestFunc1(10);
    TestFunc1(10, 20);
    //接收参数时反而从左往右给，因为函数有可能是半缺省。
    TestFunc2(10, 20);
    system("pause");
    return 0;
}

特性：

1.半缺省参数必须从右往左依次来给出，不能间隔着给。
2. 缺省参数不能在函数声明和定义中同时出现。因为，如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。
3. 缺省值必须是常量或者全局变量。
4. C语言不支持（编译器不支持）

4.函数重载：

函数重载：函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。与返回值类型相同无关（如果函数仅仅是返回值不同，则不为函数重载）。

注意：函数重载必须在相同的作用域，条件：函数名字必须相同，参数列表必须不同。

Extern” C”转为C语言

5.引用：

● 函数传参：
传地址
优点：可以通过形参改变外部的实参效率高
缺点：不安全，形参的错误改变也会影响外部实参的值（指针在里面要判空）可读性差
传值
优点：可以起到对实参的保护
缺陷：不能通过形参改变外部实参，效率低
C++中的别名（引用）可以实现传值的高效率操作。

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

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

● 引用在底层是按照指针的方式处理的
Int& ra=a;                 T&-----àT*const
Int* const pa=&a;
Pa=&b;
Const int& cra=a;                   const T&------àconst T*const

● 引用和指针的区别：
语法概念层面：引用变量只是别名，没有实际空间，与其实体共用同一块内存（有区别）
底层实现上：引用就是指针，引用实际上是有空间-----------地址（无区别）

1.引用在定义时必须初始化，指针没有要求。
2.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
Int* pa=&a;    Int*
const p=&a;
Pa=&b; 错
3.没有NULL 引用，但有NULL指针。
4.在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占占4个字节）
5.引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
6.有多级指针，但是没有多级引用。
7.访问实体方式不同，指针需要显示解引用，引用编译器自己处理。
//int main()
//{
// int a = 10;
// int b = 20;
//
// int& ra = a;//int*
// ra = 20;
//
// int* pa = &a;
// *pa = 20;
//
// return 0;
//}
8.引用比指针使用起来相对更安全。

6.内联函数

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

特性

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

#include"Add.h"
int main()
{
    Add(10, 20);
    return 0;
}

链接错误：main.obj : error LNK2019: 无法解析的外部符号"void __cdeclf(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用
所以inline不建议声明和定义分离，分离会导致链接错误。inline被展开后，就没有函数地址了，链接就会找不到，只能在当前文件使用。

7.宏常量&宏函数

#define PI 3.14
//宏常量 代码可读性高  一改都改
//缺陷 宏定义错误不好发现
int main()
{
    int r = 2;
    double s = PI*r*r;
    system("pause");
    return 0;
}

//C++11对宏常量缺陷修改
int main()
{
    const int a = 10; 
    //a定义为常量  
    /*宏常量的属性（预处理阶段替换）  
        const在编译阶段替换*/
    //const的安全性较高
    //int array[a];
    int* pa = (int*)&a;
    *pa = 100;
    cout << a << endl; //编译阶段a直接被替换为10 尽管指针把a改为100，但打印的是10
    cout << *pa << endl;
    return 0;
}

#define MAX(a,b) (((a)>(b))?(a):(b)
 int main()
{
    int a = 10;
    int b = 20;
    cout << MAX(a, b) << endl;//20
    cout << MAX(++b, a) << endl;//22,在比较与返回a的时候多加了一次  有时具有宏作用 不会参与编译
    return 0;
}

8.auto

C++11中，auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int main()
{
    auto a = 10;
    auto b = 12.34;
    auto c = a + b;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    cout << c << endl;
    //auto d;  注意：无法通过编译，使用auto定义变量时必须对其进行初始化，
    //因为，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型，没有声明就无法推导。
    //因此，auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译阶段会将auto替换为变量实际的类型。
    system("pause");
    return 0;
}

auto的使用细则

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

int main()
{
    int a = 10;
    auto pa1 = &a;
    auto* pa2 = &a;
    auto& ra = a;
    cout << typeid(pa1).name() << endl; //int *
    cout << typeid(pa2).name() << endl; //int * 因为a是整形，取地址
    //因此，auto与指针结合在一起，auto* 与auto
没有任何区别。
    cout << typeid(ra).name() << endl; //int
    //但是，auto与引用结合在一起，必须要加引用的标记。若不加与普通整形一样。
    return 0;
}

在同一行定义多个变量

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

auto不能推导的场景

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

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导,缺省值也不行 
void TestAuto(auto a) {}
int main()
{
    /*auto a = 1, b = 2; 
    auto c = 10, d = 12.34;*/
    return 0;
}

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

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

3.为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4.auto在实际中常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。
5.auto不能定义类的非静态成员变量
6. 实例化模板时不能使用auto作为模板参数

9.范围的for

C++11中引入了基于范围的for循环。
for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor() { 
    int array[] = { 1, 2, 3, 4, 5 };   
    for (auto& e : array)        
        e *= 2;        
    //使用范围for时，若要对数组中的内容进行修改，则须加引用&
    for (auto e : array)        
        cout << e << " ";        
}

int main() {
    int* p1 = NULL;    
    int* p2 = 0;        
    // …… 
    return 0;
} 

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

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

int main() { 
    TestFunc(0);    
    TestFunc(NULL);    
    TestFunc((int*)NULL);    
    return 0;
}

10.nullptr

NULL被定义成0，无法通过f(NULL)调用指针版本的f(int*)函数。
C++11给出了全新的nullptr表示空值指针。
typedef decltype(nullptr) nullptr_t;
nullptr是值0，有类型的，其类型为nullptr_t，仅仅可以被隐式转化为指针类型，nullptr_t被定义在头文件中。

● 预处理；编译；汇编；链接；可执行程序。

【面试题】

● 宏的优缺点？

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

● C++有哪些技术替代宏？
宏常量定义：换用const
宏函数定义：换用内联函数