C++ Primer 学习笔记（持续更新......）

最新推荐文章于 2023-09-19 17:20:37 发布

原创

最新推荐文章于 2023-09-19 17:20:37 发布 · 6.7k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#c++-primer #总结

这篇笔记详细探讨了C++ Primer中的关键概念，包括struct与class的区别、容器的迭代器、指针与引用的使用、二叉树遍历和搜索算法。还介绍了函数参数传递、动态内存管理以及C++的预处理、多态和动态绑定等核心特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本笔记主要是一个记录，整理和总结一下C++学习过程中的知识点。

struct和class 区别：两个关键字都是进行类的定义。struct也可以定义类，和class定义的类唯一不同之处就在于默认的初始访问级别，struct在不声明public或者private的时候默认是public，class是private。

容器的迭代器：是一种检查容器内元素并遍历元素的数据类型，可以理解成指针。比如vector的迭代器：

vector<int>::iterator iter = ivec.begin()
//这就是定义了iter这个迭代器，指向ivec的第一个元素
*iter = 0//将ivec的第一个元素置零
for(vector<int>::iterator iter = ivec.begin(); iter!= ivec.end();++iter)
    *iter = 0;
//将所有元素置零

如果关键字是const_iterator，那么就不允许进行赋值

* 与 &: *是解引用操作符，用来获取指针所指向的对象，&是引用操作符，用来获取地址。
指针与引用： 指针保存的是另外一个对象的地址，一般初始化方法比如：int *p = &a; int *p = 0;(此时表示不指向任何对象)，注意，不要使用未初始化的指针。一个有效的指针一定是如下三种状态之一：1. 保存一个特定对象的地址；2。指向某个对象后面的另一对象，如 node *a = n->next；3. 0值
对指针的操作：对指针进行解引用操作能够访问所指的对象，也可以直接修改指针本身的值，使其指向另外一个对象。
引用：实际是定义的一个别名，比如：int &ra = a; 之后对ra的操作就是直接改变a的值。
指针和引用的区别：引用总是指向某个对象，所以定义引用的时候没初始化是错误的；对引用进行赋值改变的是指向的对象的值，而不是让该引用指向另外的对象。
指针对数组的操作：
```
int ia[] = {0,2,3,6,8};
int *ip = ia;// ip points to ia[0]
ip = &ia[4]// ip points to ia[4]
ip = ia;
int *ip2 = ip + 4;// ip2 points to ia[4]
*(ip+4); // 8
//多维数组
int ia[3][4] = {
    
    {0,1,2,3},{4,5,6,7},{8,9,10,11}};
int (*pia)[4] = ia;
cout<<*(*pia+1)<<endl<<*(*(pia+1)+1)<<endl;// 1 5 pia是ia[0]的地址，*pia是ia[0][0]的地址
```

箭头操作符与点操作符： 箭头操作符->实际上是一个点操作符和解引用操作符的同义词，比如：

        classa *pa = &ca;
        (*pa).func();
        //其实等同于：
        pa->func()
        //箭头操作符是指针专用

函数参数传递： 分为值传递，指针形参，引用形参。其中值传递是形参复制实参，调用函数里面不影响实参；指针传递是形参复制实参指针，调用函数并不影响实参指针，但是会影响指针指向的对象；引用传递会影响到实参。
有些时候，需要用到指针传递，比如一个简单的swap函数，swap(int *a,int *b)，在调用的时候就是swap(&x,&y)，这样在书写的时候比较麻烦。我们还可以用引用传递来代替指针传递，效果是一样的，swap函数定义为：swap(int &a, int &b)，调用的时候比较简单:swap(x,y)。调用的过程中，发生了两个引用类型的变量定义：int &a = x,int &b = y. 即a,b分别是x,y的别名。
new函数返回的是一个指针

二叉树前序，中序，后序遍历的非递归实现：

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
  struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };

class Solution {
public:
    vector<int> midorderTraversal(TreeNode *root) {
        vector<int> vec;
        if(root == NULL){return vec;}
        stack<TreeNode*> st;
        TreeNode *cur = root;
        while(!st.empty() || cur){
            while(cur){
                st.push(cur);
                cur = cur->left;
            }
            if(!st.empty()){
                cur = st.top();
                st.pop();
                vec.push_back(cur->val);
                cur = cur->right;
            }
        }
        return vec;
    }
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> vec;
        if(root == NULL){return vec;}
        stack<TreeNode*> st;
        st.push(root);
        TreeNode *cur = NULL;
        while(!st.empty()){
            cur = st.top();
            st.pop();
            vec.push_back(cur->val);
            if(cur->right){
                st.push(cur->right);
            }
            if(cur->left){
                st.push(cur->left);
            }
        }
        return vec;
    }
    vector<int> postorderTraversal(TreeNode *ro