C++基础入门

灰太狼 2023-05-31 04:57 11阅读 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++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率；内联函数，在编译期间编译器会**用函数体替换函数的调用。**

**特性**

1.  inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2.  inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
3.  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;
    }

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

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  
宏函数定义：换用内联函数