• c++基础2

    一、new和delete

    1.知识点

    在c++中用来申请堆区的内容空间，new等价与c语言中的malloc，delete等价于C语言中的free

    (c++兼容c)

    1. double* p=(double*)malloc(sizeof(double)*10);
    2. *p=5;//访问的是8个字节

    对于指针解引用访问的是 指针的类型（不加*的部分）大小的字节数

    指针+n，移动的字节数是 指针的类型（不加*的部分）大小的字节数

    1. int a = 0;
    2. char* p = (char*)&a;
    3. *p = 'a';
    4. *(p + 1) = 'b';
    5. *(p + 2) = 'c';
    6. //*(p + 3) = '\0';
    7. printf("%s\n", (char*)&a);//abc

    new

    1. int* p=new int;
    2. int** p1=new int*;
    3. int*** p2=new int**;

    2.new使用

    1. //1.申请单个内存
    2. int* p=new int;
    3. //2.申请的单个被初始化的内存
    4. int* p1=new int(100);
    5. //3.申请多个连续的空间
    6. int* p2=new int[10];

    3.new的特性

    1.new是运算符

    2.new可以分配两种内存，一种是单个内存，一种是连续的内存

    3.new只有分配单个内存的时候可以同时给该内存复赋值，分配连续多个内存是无法同时赋值的

    4.如果要给连续的内存同时赋值用memset，可以给连续的内存空间初始化

    4.delete的使用

    1. //1.释放单个内存
    2. delete p;
    3. p=NULL;//置空，防止p成为野指针
    4. //2.释放多个内存
    5. delete []p;
    6. p=NULL;

    5.delete的特性

    1.delete是运算符

    2.delete可以释放两种内存，一种是单个内存，一种是连续内存

    3.delete释放内存时，指针必须指向内存首地址

    4.释放完内存之后要记得给指针赋值NULL操作，否者会产生野指针

    6.动态内存操作中常见的问题

    1. //1.没有给指针分配内存，就对该指针解引用赋值
    2. int* p;
    3. *p=10;
    4. //2.给指针分配内存成功，但是没有初始化就使用了
    5. int* p=new int;
    6. printf("%d\n",*p);
    7. //3.内存分配成功，也初始化了，但是操作越界
    8. int* p=new int[5];
    9. *(p+7)=123;
    10. /*
    11. 这种操作通常情况下应该都可以正常运行，但是会有很大的问题，因为你不知道越界的地方是否有在使用的数据，如果有那么这种越界操作就会改变那个地方的数据，然后出现一些问题
    12. */
    13. ​
    14. //4.忘记释放内存，造成内存泄漏
    15. ​
    16. //5.释放内存后继续使用
    17. int* p=new int;
    18. *p=10;
    19. delete p;
    20. *p=20;//释放了内存，就不能继续使用了

    7.动态数组

    1. #include 
    2. #include
    3. int* p = NULL;//用来申请内存的指针
    4. int len = 0;//元素个数 ， 插入位置
    5. int maxSize = 0;//最大容量
    6. ​
    7. void insert(int data) //尾插法插入元素
    8. {
    9.     if (len >= maxSize)//元素个数>=最大容量，说明放满了，需要扩容
    10.     {
    11.         maxSize = maxSize + (((maxSize >> 1) > 1) ? (maxSize >> 1) : 1);
    12.         printf("<%d>", maxSize);
    13.         int* temp = new int[maxSize];
    14.         memcpy(temp, p, sizeof(int)*len);//将原来p中的内存有多少就拷贝多少到temp中
    15.         if (p != NULL)//如果指针不为空，将其释放
    16.         {
    17.             delete[]p;
    18.         }
    19.         p = temp;//p指向新的内存（先释放再指）
    20.     }
    21.     p[len] = data;//尾插
    22.     len++;//元素+++1
    23. ​
    24. }
    25. ​
    26. void insert(int index, int data)
    27. {
    28.     if (index<0 || index>len)
    29.     {
    30.         return;
    31.     }
    32.     if (len >= maxSize)
    33.     {
    34.         maxSize = maxSize + ((maxSize >> 1) > 1 ? (maxSize >> 1) : 1);
    35.         int* temp = new int[maxSize];
    36.         memcpy(temp, p, sizeof(int)*len);
    37.         if (p != NULL)
    38.         {
    39.             delete[]p;
    40.         }
    41.         p = temp;//p指向temp，也得到了里面的内容
    42.     }
    43.     for (int i = len - 1; i >= index; i--)
    44.     {
    45.         p[i + 1] = p[i];
    46.     }
    47.     p[index] = data;
    48.     len++;
    49. }
    50. ​
    51. ​
    52. void delete_last()//删除最后一个元素，只是在逻辑上被删除了，实际上还是存在于计算机内存中
    53. {
    54.     len--;
    55. }
    56. ​
    57. void dele(int index)//元素位置
    58. {
    59.     if (index<0 || index>len)
    60.     {
    61.         return;
    62.     }
    63.     for (int i = index; i < len; i++)
    64.     {
    65.         p[i] = p[i + 1];
    66.     }
    67.     len--;
    68. }
    69. ​
    70. //修改元素
    71. void change(int index, int data)
    72. {
    73.     if (index<0 || index>len)
    74.     {
    75.         return;
    76.     }
    77.     for (int i = 0; i < len; i++)
    78.     {
    79.         if (i == index)
    80.         {
    81.             p[index] = data;
    82.             return;
    83.         }
    84.     }
    85.     printf("没有这个元素\n");
    86.     
    87. }
    88. ​
    89. //查找元素
    90. void find(int index)
    91. {
    92.     if (index<0 || index>len)
    93.     {
    94.         return;
    95.     }
    96.     for (int i = 0; i < len; i++)
    97.     {
    98.         if (i == index)
    99.         {
    100.             printf("数组下标%d对应的元素为：%d\n", index, p[index]);
    101.             return;
    102.         }
    103.     }
    104.     printf("没有这个下标\n");
    105. }
    106. ​
    107. void print()
    108. {
    109.     for (int i = 0; i < len; i++)
    110.     {
    111.         printf("%d\t", p[i]);
    112.     }
    113. }
    114. ​
    115. ​
    116. ​
    117. int main()
    118. {
    119. ​
    120.     for (int i = 0; i < 10; i++)
    121.     {
    122.         insert(i + 1);
    123.     }
    124.     printf("\n");
    125.     print();
    126.     printf("\n");
    127.     delete_last();
    128.     insert(3, 100);
    129.     dele(5);
    130.     change(3, 20);
    131.     find(6);
    132.     print();
    133.     delete[]p;
    134.     p = NULL;
    135. ​
    136.     getchar();
    137.     getchar();
    138.     return 0;
    139. }
    ​
​

    二、命名空间

    1.知识点

    1.命名空间是用来组织和重用代码的编译单元

    2.在编写代码时写的程序不可能所有的标识符都没有重名现象，在多人协同开发时更加不可控，尤其对于库来说问题更加严重。为了解决重名现象，通过命名空间来解决冲突。

    3.命名空间中的东西对外是不开放的，外面不能直接访问命名空间中的成员

    2.命名空间的定义

    1. namespace 命名空间标识符
    2. {
    3.     命名空间成员
    4. }
    5. //花括号只有两种情况：1.定义域（必须加分号）
    6. //                  2.作用域（可加可不加）

    3.注意

    1.命名空间标识符必须满足标识符的命名规则和命名规范，习惯名字唯一，通常以开发团队的名字（项目名）来命名

    2.命名空间可以在全局，也可以在局部（命名空间接受嵌套定义），但不能在函数内和类中定义

    3.命名空间的花括号是作用域

    4.注意命名污染，尽量规避同名的出现，如果两个命名空间同名，那么就会合并两个命名空间

    4.命名空间访问

    1. #include 
    2. ​
    3. namespace yunfei
    4. {
    5.     int age = 18;
    6.     void fun1()
    7.     {
    8.         printf("age:%d",age);
    9.     }
    10.     namespace feiyun
    11.     {
    12.         int age = 19;
    13.         void fun2()
    14.         {
    15.             printf("age:%d", age);
    16.         }
    17.     }
    18. }
    19. ​
    20. ​
    21. int main()
    22. {
    23. ​
    24.     getchar();
    25.     getchar();
    26.     return 0;
    27. }
    28. ​
    29. ​

    作用域运算符 ：：

    可以理解为，什么的什么

    1.using声明

    using 命名空间名称 ：： 空间成员名称；

    using yunfei::feiyun::fun2;

    2.using 指示

    using namespace 命名空间名

    放开该命名空间的所有权限（所有成员都在空间外可见），适用于该空间的大部分成员都需要经常被使用

    using namespace yunfei;
//把yunfei空间下的所有成员访问都公开出来，都可以在外面访问

    3.命名空间名称：：空间成员名称，直接访问空间下的某一个成员

    yunfei::feiyun::fun2();

    5.命名空间取别名

    1.namespace 别名=命名空间名

    2.当命名空间标识符过长或不太方便记忆，可通过取别名的方式来表示该命名空间，别名的操作等价于原命名空间

    6.命名空间成员的声明及定义

    namespace A                 void A::fun()
{                               {
    void fun();                     //函数功能
}                               }
//声明                    命名空间外实现

    三、cin和cout

    1.使用前准备

    1.需要包含头文件

    2.需要声明命名空间std中的权限

    3.c++的头文件，不带.h , 如果你要包含C语言的头文件正常写，c++兼容C语言，或者#include

    i
    1. nt main()
    2. {
    3.     int a = 10;
    4.     char str[] = "awubdjajs";
    5.     cout << str << a << endl;
    6.     cout << "ei\tfi\arv\b\nprv" << endl;
    7.     cin >> a >> str;//两个输入之间用空格区分
    8.     cout << a << endl << str << endl;
    9.     system("pause");
    10.     return 0;
    11. }

    四、string的基本使用

    1.知识点

    1.string是c++中的字符串。类似于C语言中的字符数组

    2.string是系统提供的一个类

    2.基本使用

    1.需要包含头文件和声明命名空间std中的权限

    2.赋值：

    string str1=“adnwd”，str2;

    str2 = str1;

    3.求长度：

    int len = str1.length();

    4.清空字符串：

    str1.clear();

    5.判断字符串是否为空：

    if(str1.empty()==NULL)

    6.比较字符串是否相同：

    if(str1==str2)

    7.得到字符串中某一个位置的字符

    char c=str1[3];

    char a=str1.at(3);

    注意：这两个3指的是字符串中下标（从0开始)为3的字符，不能越界。

    1. #include
    2. #include
    3. using namespace std;
    4. ​
    5. int main()
    6. {
    7.     string str1 = "asgwd";
    8.     string str2 = "aaaaaaa";
    9.     if (str1 == str2)
    10.     {
    11.         cout << "相等" << endl;
    12.     }
    13.     else
    14.     {
    15.         cout << "不相等" << endl;
    16.     }
    17.     cout << str1.length() << endl;
    18.     //得到w
    19.     cout << str1.at(3) << endl;
    20.     cout << str1[3] << endl;
    21.     str1[3] = 'a';//修改字符串中的字符
    22.     cout << str1 << endl;
    23. ​
    24.     //字符串之间直接赋值，不需要函数（重载）
    25.     str1 = str2;
    26. ​
    27. ​
    28.     system("pause");
    29.     return 0;
    30. }

    补充：

    1.三目运算符，在C语言中，返回的是一个常量，不能被赋值的，c++返回的是变量

    2.c++的函数必须要写返回值类型

    3.在全局下面，c++不允许 int a;int a=10;这种二义性操作

  • 相关阅读:
    Android studio控制台 输出乱码解决方法
    【C\C++】内存分配 和 动态内存管理方式
    MySQL之查询性能优化(四)
    Go-Python-Java-C-LeetCode高分解法-第十一周合集
    Google Earth Engine（GEE）——全球洪水数据库 v1 (2000-2018年)
    CSS学习笔记（三）
    深度学习 LSTM长短期记忆网络原理与Pytorch手写数字识别
    Tensorflow 2.1 MNIST 图像分类
    【JAVA】SpringMVC（下）—— SSM整合&异常处理器
    【小样本学习】2022 KDD Task-Adaptive Few-shot Node Classification
  • 原文地址：https://blog.csdn.net/m0_52559870/article/details/126162958