2021-07-06 C++学习笔记

1.本质：对于c语言的一种扩展和进阶 一门面向对象的语言

最早是代类c语言 编译器用的还是gcc

是对C语言的简化

2.面向过程和面向对象的区别

计算两个数的和：

面向过程：输入两个数，求和，输出

面向对象：创建一个可以解决问题的对象→创建一个整型对象→给这个对象分配条件→给这个对象一个做加法的功能 不需要一次一次地去调用函数

3.编程方式：

①面向过程 可以编译C

②面向对象编程 （4天）

③泛型编程（难点，15天）：广泛，简洁，节省代码量，耦合度低，比如实现两个数相加，创建一个对象，可以两个整型相加，可以两个浮点相加，可以实现一个字符和一个整型相加

c语言也可以使用泛型编程

任何数据类型都可以转化为void *

任务：用C语言写泛型编程的冒泡排序

4.头文件：c11 2011的c++标准

(1)所有的C库功能的头文件如stdfto.h,stdlib.h,string.h依然支持，它们已经不在std的命名空间里面

C+ +将这些C的原始库文件进行了重新的编排然后放到了std的命名空间里，cstdio,cstdlib,cstirng

(2)iostream.h,fstream.h,老的C+ +头文件依然被支持,但是也已经不在std的命名空间里

(3)最新的C+ +头文件iostream,fstream直接包含在std的命名空间里

在标准化的过程中，不会对功能进行大幅度的修改,修改-些标准细节, 所以新的头文件和老的头文

件不一定完全对应

#include <iostream> //标准输入输出流头文件 
int main() 
{ 
    return 0;
}

编译方法：采用gcc 链接stdc++库 或者采用g++

5.命名空间:

(1)::域解析符

(2)可以放变量和函数，结构体(域解析附放在结构体的名字前)

(3)命名空间可以进行嵌套

(4)为了解决合作开发时的命名冲突问题，C++引入了命名空间(Namespace) 的概念。

命名空间将全局作用域分成不同的部分不同命名空间中的标识符可以同名而不会发生冲突

(5)std是C++最大的一个命名空间，C+ +将这些C的原始库文件进行了重新的编排然后放到了std的命名空间里

(6)一个中大型软件往往由多名程序员共同开发，会使用大量的变量和函数，不可避免地会出现变量或函数的命名冲突。当所有人的代码都测试通过，没有问题时，将它们结合到一起就有可能会出现命名冲突。为了解决合作开发时的命名冲突问题，C++引入了命名空间(Namespace) 的概念。

(7)命名空间将全局作用域分成不同的部分，全局作用域也叫默认命名空间

定义命名空间 
namespace A 
{ 
    int a; //全局变量 
}
 
namespace B 
{ 
int a; 
}

#include <iostream>  //标准输入输出流头文件
#include <cstring>
using namespace std; //标准c++的命名空间

namespace A
{
    int a;  //全局变量
    void print()
    {
        printf("this is A\n");
    }
    struct test
    {
        int a;
    };
    namespace C
    {
        int a;
    }
}

namespace B
{
    int a=0;
    void print()
    {
        printf("this is B\n");
    }
    
}

int main()
{
    using namespace A;
    a=1;
    char str[20]={0};
    char str1[]="hello";
    strcpy(str,str1);
    printf("%s\na=%d\nB.a=%d\n",str,a,B::a);
    A::print();
    B::print();
    struct A::test tt; //struct为关键字，域解析符要放在test前
    A::C::a=2;
    printf("%d\n",A::C::a=2);
    return 0;
}

6.c++对c的一些加强

(1)输入流和输出流

①cout//输出流对象

②>>重定向符号

③输入输出流的改进：cin cout : iostream类的实例对象

(2)使用时定义

如，for(int i=0;i<10;i++)

减小了变量的生命周期，节省内存空间

(3)bool类型：用来判断真假 只占一个字节

赋值只要不是零，不管正数负数都是1

(4)三目运算符

<> ? :

a>b?a:b输出是值还是变量?

在c里输出的值，在c++里输出的变量

#include <iostream>
using namespace std;

int main()
{
    int a=10;
    int b=20;
    (a>b?a:b)=30;
    cout<<a<<endl<<b<<endl;
    return 0;
}

(5)auto关键字

①自动推导数据类型

auto i=1;sizeod(i)=4;

auto i='a';sizeof(i)=1

②使用时必须初始化

(6)const

在c语言里：用指针还是可以修改 伪常量

在c++里：不可以通过指针修改 真常量

它在编译时已经确定为定值 没有内存

常量的值放在符号表里，没有内存空间，不能被修改值

int main()
{    
    const int a=20;
    int *p=&a;
    *p=30;//并不会修改a的值
    //明面上p确确实实指向a的地址
    //但是编译后不会从内存空间取值，而是直接从符号表取值
    //在符号表里a就代表某个数
}

7.引用

函数在传递参数时只能传值，不能传变量，所以需要指针，但指针本身就占内存，不是一个很好的工具，可读性不强，会让代码变复杂，所以需要引用，引用可以替代指针的作用

(1)本质：一块内存的别名

(2)用途：作为函数参数进行内存的传递

void swap(int &a,int &b)
{
    int c=a;
    a=b;
    b=c;
}
int main()
{
    int a=10;
    int b=20;
    int &d=a; //引用初始化,相当与给a起了一个小名
    //&d=b;//错误，与a的绑定关系不会变
    swap(a,b);
    cout<<"a="<<a<<endl<<"b="<<b<<endl;
    return 0;
}

(3)特点：

①初始化时要进行绑定

②绑定关系一旦成立，就不会修改

好处：

①避免了形参的创建，传递的是内存，不需要在函数里定义形参，接收传过来的值，更快的参数传递②作为函数的返回值，避免了副本的创建

const int &d=a;//常引用

constexpr在编译阶段就得到计算结果的表达式

//不能通过引用修改原变量的值，只能用，不能改

是一种很强的约束，保证语义不被破坏，更好

相比宏来说，没有额外的开销

(4)任务：指针和引用的区别（4点）

本质：引用是一个内存的别名，指针是一个变量，指向某个变量的内存

内存分配：引用不需要另外开辟内存空间，指针实际是变量，所以需要开辟，引用在使用时需要初始化

级数：指针又多级指针，引用没有

使用效率：指针会传递参数时会空指针，错误指针，而引用不会，提高了一点效率，但如果不出错，两者的效率几乎相同

8.左值和右值

(1)左值：

lvalues (left values):存在于单个表达式之外的对象

int x=1+2; x是左值

(2)右值：

rvalues：只存在于单个表达式之内//1+2是右值

无内存的临时对象

(3)左值引用：给一个对象加上另外一个别名 int &a=b;

(3)右值引用：int &&a=b;移动语义：移动对象

9.new:malloc delete:free

new和delete是关键字

任务：

new/delete和malloc/free的区别（6点）

1.关键字，函数

2.malloc使用要调用库文件，new是c++的一部分，不需要

3.内存，整体，分开

4.malloc返回的是（void*)指针进行强转，new

5.内存的空间分配：malloc需要计算，new会自动计算

6.malloc申请失败，返回空指针，new申请失败，会报异常

二维数组本质是指针数组

a[2][3]

两个指针分配指向一个3个元素的数组

    int **b=new int*[2];//先开辟一个指针数组，有两个指针元素，分配用来指向两个三元素的数组
    for(int i=0;i<2;i++)
    {
        b[i]=new int[3];//给每个指针开辟3个int空间
    }
    for(int i=0;i<2;i++)
    {
        for(int j=0;j<3;j++)
        {
            b[i][j]=3*i+j+1;
           cout<<b[i][j]<<endl;
        }
    }
        for(int i=0;i<2;i++)
    {
        delete []b[i];
    }
    delete []b；

10.用using代替typedef 起到限制作用域的作用

int main() { using INT = int;//可以限制在函数内 INT a=0; return 0; }