03.栈

最新推荐文章于 2024-08-29 18:44:48 发布
最新推荐文章于 2024-08-29 18:44:48 发布
阅读量153 收藏
点赞数
分类专栏： 数据结构 学习记录 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51421734/article/details/126533365
版权

栈

1. 介绍

  • 先入后出的有序列表
  • 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。

允许插入和删除的一端为变化的一端，成为栈顶（Top），另一端为固定的一端，成为栈底（Bottom）

  • 最先放入的元素在栈底，最后放入的在栈顶，而删除元素则相反，最后放入的元素最先删除，最先放入的元素最后删除

img
应用场景：

1.子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。

2.处理递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。

3.表达式的转换[中缀表达式转后缀表达式]与求值

4.二叉树遍历

5.图形的深度优先(depth-first)搜索法

2. 思路分析和代码实现

img

1.使用数组来模拟栈

2.定义一个top来表示栈顶，初始化为-1

3.入栈的操作，当有数据加入到栈时，top++; stack[top] == data;

4.出栈的操作。int value = stack[top]; top–; return value;

代码实现：

/**
 * 数组模拟栈
 *
 * @author GHC
 * @date 2022/7/11 13:37
 */
public class A1ArrayStackDemo {

    public static void main(String[] args) {
        // 测试ArrayStack
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        // 控制是否退出菜单
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);

        while (loop){
            System.out.println("show：显示栈");
            System.out.println("exit：退出程序");
            System.out.println("push：入栈");
            System.out.println("pop ：出栈");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key){
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数字：");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try{
                        int res = stack.pop();
                        System.out.println(res + "出栈");
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出！");

    }
}

/**
 * 定义一个ArrayStack表示栈
 */
class ArrayStack {

    /**
     * 栈的大小
     */
    private int maxSize;

    /**
     * 数组，数组模拟栈，数据就放在该数组
     */
    private int[] stack;

    /**
     * 栈顶top，初始值-1
     */
    private int top = -1;

    /**
     * 构造器
     *
     * @param maxSize
     */
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    /**
     * 栈满
     */
    public boolean isFull() {
        return top == maxSize - 1;
    }

    /**
     * 栈空
     */
    public boolean isEmpty() {
        return top == -1;
    }

    /**
     * 入栈
     */
    public void push(int value) {
        // 判是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    /**
     * 出栈
     */
    public int pop() {
        // 判空
        if (isEmpty()) {
            throw new IllegalArgumentException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    /**
     * 遍历栈，遍历时需要从栈顶开始显示数据
     */
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d \n", i, stack[i]);
        }
    }

}

练习：使用链表模拟栈

3. 栈实现综合计算器(中缀表达式)

例：输入[7x2x2-5+1+3-4] 计算结果

img

思路：

1.通过一个index值（索引），来遍历我们的表达式

2.如果我们发现是一个数字，就直接入数栈

3.如果扫描到的是一个符号，就分如下情况：

​ 3.1 如果发现当前的符号栈为空，就直接入栈

​ 3.2 如果不为空，就进行比较没如果当前的操作符号的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈**。如果当前的操作符号的优先级大于或者等于栈中的操作符**，就直接入符号栈

4.当表达式扫描完毕后，就顺序的从数栈和符号栈中pop出相应的数和符号，并运算

5.最后再数只有个数字，就是结果

代码实现 ：

验证 3+2*6-2

public class A2Calculator {

    public static void main(String[] args) {
        String expression = "3+2*6-2";
        // 创建一个数栈和一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        // 定义一个相关变量，用于扫描
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        // 将每次扫描得到的char保存到ch
        char ch = ' ';
        // 用于拼接多位数
        String keepNum = "";
        // 开始循环扫描expression
        while (true) {
            // 依次得到expression的每个字符
            ch = expression.substring(index, index + 1).charAt(0);
            // 判断ch是什么，然后做相应处理
            if (operStack.isOper(ch)) {
                // 判断当前的符号栈是否为空
                if (!operStack.isEmpty()) {
                    // 处理
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        // 入数栈
                        numStack.push(res);
                        // 当前符号入符号栈
                        operStack.push(ch);
                    } else {
                        // 如果当前的操作符优先级大于栈中的操作符，直接入栈
                        operStack.push(ch);

                    }
                } else {
                    // 如果为空，直接入栈
                    operStack.push(ch);
                }
            } else {
                // 如果是数，则直接入数栈
                // 存的是ASCII码 -48
                // numStack.push(ch - 48); 此时有问题，改进
                // 1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                // 2.在处理数，需要向expression的表达式的index，后看一位，如果是数就进行扫描，如果是符号栈再入栈
                // 3.因此，我们需要定义一个字符串变量，用于拼接

                // 处理多位数
                keepNum += ch;

                // 如果ch已经是expression的最后一位，就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                    // 判断下一位是不是数字，如果是数字则继续扫描，如果是符号，则入栈
                } else if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                    // 如果是最后一位运算符，入栈
                    numStack.push(Integer.parseInt(keepNum));
                    // 清空
                    keepNum = "";
                }
            }
            // 让 index+1 并判断是否到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        // 当表达式扫描完毕后，就顺序的从数栈和符号栈中pop出相应的数和符号，并运算
        while (true) {
            // 如果符号栈为空，则计算到最后结果，数栈中只有一个数字【结果】
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            numStack.push(res);
        }

        System.out.printf("表达式:%s = %d", expression, numStack.pop());

    }

}

/**
 * 定义一个ArrayStack表示栈
 * 需要扩展功能
 */
class ArrayStack2 {

    /**
     * 栈的大小
     */
    private int maxSize;

    /**
     * 数组，数组模拟栈，数据就放在该数组
     */
    private int[] stack;

    /**
     * 栈顶top，初始值-1
     */
    private int top = -1;

    /**
     * 构造器
     *
     * @param maxSize
     */
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }


    /**
     * 栈满
     */
    public boolean isFull() {
        return top == maxSize - 1;
    }

    /**
     * 栈空
     */
    public boolean isEmpty() {
        return top == -1;
    }

    /**
     * 入栈
     */
    public void push(int value) {
        // 判是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    /**
     * 出栈
     */
    public int pop() {
        // 判空
        if (isEmpty()) {
            throw new IllegalArgumentException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    /**
     * 遍历栈，遍历时需要从栈顶开始显示数据
     */
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d \n", i, stack[i]);
        }
    }

    /**
     * 返回运算符的优先级，优先级使用数字表示
     * 数字越大则优先级越高
     */
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            // 假定目前的表达式只有+ - * /
            return -1;
        }
    }

    /**
     * 判断是不是一个运算符
     */
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    /**
     * 计算方法
     */
    public int cal(int num1, int num2, int oper) {
        // 用于存放计算的结果
        int res = 0;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }


    /**
     * 返回当前栈顶的值，不是pop
     */
    public int peek() {
        return stack[top];
    }
}

练习：加入小括号

4. 前缀、中缀、后缀表达式

4.1 前缀

从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们做相应的计算（栈顶元素和次顶元素），并将结果入栈；

例：（3+4）x 5-6 前缀表达式：- x + 3 4 5 6

1.从右至左扫描，将6 5 4 3压入堆栈

2.遇到+，弹出3 4，计算出7，7入栈

3.接下来是 x ，弹出7,5 ，计算得35，入栈

4.运算 -，34 - 6 得 29

4.2 中缀

中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(前面我们讲的案例就能看的这个问题)，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)

4.3 后缀（逆波兰表达式）

1.后缀表达式又称逆波兰表达式与前缀表达式相似，只是运算符位于操作数之后

2.中举例说明:(3+4)×5-6对应的后缀表达式就是3 4+5×6-

img

**计算器求值：**从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素和栈顶元素），并将结果入栈;重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

4.4 逆波兰计算器

/**
 * 逆波兰实现计算器
 *
 * @author GHC
 * @date 2022/7/19 15:06
 */
public class A3PolandNotation {
    public static void main(String[] args) {
        // 先定义逆波兰表达式
        // (3+4)x5-6 => 3 4 + 5 x 6 -
        String suffixExpression = "3 4 + 5 * 6 - ";
        // 1. 先将suffixExpression放到ArrayList中
        // 2. 将ArrayList，配合栈完成计算（遍历）
        List<String> list = getListString(suffixExpression);
        System.out.println(list);

        int res = calculate(list);
        System.out.println("计算的结果是=" + res);
    }

    /**
     * 将逆波兰表达式，依次将数据和运算符放入到ArrayList中
     */
    public static List<String> getListString(String suffixExpression) {
        // 将suffixExpression分隔
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    /**
     * 完成逆波兰表达式的计算
     * 从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素和栈顶元素），并将结果入栈;
     * 重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果
     */
    public static int calculate(List<String> ls) {
        // 创建栈，只需要一个栈即可
        Stack<String> stack = new Stack<>();
        // 遍历ls
        for (String item : ls) {
            // 使用正则表达式取出数，匹配多位数
            if (item.matches("\\d+")) {
                // 入栈
                stack.push(item);
            } else {
                // 弹出顶栈 次顶栈，运算再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    res = num1 - num2;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new IllegalArgumentException("运算符有误！");
                }
                // res 入栈
                stack.push(String.valueOf(res));
            }
        }
        return Integer.parseInt(stack.pop());
    }
}

4.5 中缀表达式转后缀表达式

1.初始化两个栈：运算符s1和存储中间结果的栈s2

2.从左至右扫描中缀表达式

3.遇到操作数，压入s2

4.遇到运算符时，比较其与s1栈顶运算符的优先级：

​ 4.1 如果s1为空，或栈顶运算符为左括号（，则直接将此运算符入栈；

​ 4.2 否则，若优先级比栈顶运算符的高，也将运算符压入s1；

​ 4.3 否则，将s1栈顶的运算符弹出并压入s2，再次转到（4.1）与s1中新的栈顶运算符比较；

5.遇到括号时：

​ 5.1 如果是左括号，直接压入s1；

​ 5.2 如果是右括号，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃；

6.重复步骤2-5，直到表达式最右边

7.将s1中剩余的运算符依次弹出并压入s2

8.依次弹出s2中的元素并输出，结果的逆序即为中缀转后缀

例子

中缀：1+((2+3)x4-5) => 1 2 3 + 4 x + 5 -

img

   /**
     * 将中缀表达式转成对应的List
     */
    public static List<String> toInfixExpressionList(String s) {
        // 定义一个list，存放在中缀表达式对应的内容
        List<String> ls = new ArrayList<>();
        // 这是一个指针，用于遍历中缀表达式字符串
        int i = 0;
        // 对多位数拼接
        StringBuilder str;
        // 每遍历到一个字符就放入c
        char c;
        do {
            // 如果c是一个非数字，我需要加入到ls
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                // 指针后移
                i++;
            } else {
                // 如果是一个数字，则需要拼接
                // 先将str置空,'0'[48] -> '9'[57]
                str = new StringBuilder();
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    // 拼接
                    str.append(c);
                    i++;
                }
                ls.add(str.toString());
            }
        } while (i < s.length());
        return ls;
    }

    /**
     * 中缀表达式的List转后缀表达式的List
     */
    public static List<String> parseSuffixExpressionToList(List<String> ls) {
        // 定义两个栈
        // 符号栈
        Stack<String> s1 = new Stack<>();
        // 存储中间结果，s2没有pop操作，因此用List代替
        List<String> s2 = new ArrayList<>();

        // 遍历ls
        for (String item : ls) {
            // 如果是一个数就入栈，加入s2
            if (item.matches("\\d+")) {
                s2.add(item);
                // 如果是左括号，直接压入s1
            } else if ("(".equals(item)) {
                s1.push(item);
                //  如果是右括号，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
            } else if (")".equals(item)) {
                while (!"(".equals(s1.peek())) {
                    s2.add(s1.pop());
                }
                // 消除一对括号
                s1.pop();
            } else {
                // 当s1栈顶的运算符的优先级小于等于栈顶运算符的优先级，将s1栈顶的运算符弹出并压入s2，再次转到（4.1）与s1中新的栈顶运算符比较
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                // 将item压入s1
                s1.push(item);
            }
        }
        // 将s1中剩余的运算符依次弹出并压入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }
        return s2;
    }
/**
 * 判断运算符对应的优先级
 */
class Operation {
    private static final int ADD = 1;
    private static final int SUB = 1;
    private static final int MUL = 2;
    private static final int DIV = 2;

    /**
     * 返回对应优先级数字
     */
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在改运算符");
                break;
        }
        return result;
    }
}

结果

String expression = "1+((2+3)*4-5)";
List<String> toInfixExpressionList = toInfixExpressionList(expression);
System.out.println("中缀表达式" + toInfixExpressionList);
List<String> parseSuffixExpressionToList = parseSuffixExpressionToList(toInfixExpressionList);
System.out.println("后缀表达式：" + parseSuffixExpressionToList);
System.out.println("结果：" + calculate(parseSuffixExpressionToList));

中缀表达式[1, +, (, (, 2, +, 3, ), *, 4, -, 5, )]
后缀表达式：[1, 2, 3, +, 4, *, 5, -, +]
结果：16
Gggghc
关注
专栏目录
03-栈与队列
Laic Zhang的博客
05-12 2935
3.1 栈 ​ 3.1.1 抽象数据类型栈的定义 ​ 3.1.2 栈的表示和实现 3.2 栈的应用举例 ​ 3.3.1 数制转换 ​ 3.3.2 括号匹配的检验 ​ 3.3.4 行编辑程序 ​ 3.3.5 迷宫求解 ​ 3.3.5 表达式求值 3.4 队列 ​ 3.4.1 抽象数据类型栈的定义 ​ 3.4.2 链队列—队列的链式表...
C语言数据结构 广工 作业系统 03.栈和队列
03-10
### C语言数据结构：栈与队列应用案例分析 #### 案例一：字符序列匹配验证 在本案例中，我们需要设计一个算法来判断一个输入的字符序列是否符合特定的模式，即“序列1&序列2”，其中序列2是序列1的逆序。具体而言...
C# Stack.ElementAt(int index)
xwwwill的博客
01-08 1422
C# Stack.ElementAt(int index) 栈中取值：index是栈的索引值，从0开始，如果是0,就取栈顶的元素，因为栈是后进先出的原则； 举例： using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; na...
笔记_408_数据结构_03. 栈和队列
m0_61749596的博客
06-11 988
nn11​C2nn​。
数据结构-03.栈和队列
sandalphon4869的博客
10-05 451
文章目录3.1.栈3.1.2 栈的存储结构和实现顺序栈的C语言实现顺序栈的基本操作实现StackEmpty()顺序栈的初始化顺序栈的元素入栈3.2.队列 3.1.栈 3.1.2 栈的存储结构和实现 顺序栈的C语言实现 // 初始容量 #define STACK_INIT_SIZE 100; // 容量的增量 #define STACKINCREMENT 10; typedef struct { ElemType *base; //栈底指针，栈构造前和销毁后为空 ElemType *top;
03.顺序栈的简单案例
chongyang_的博客
11-08 1719
#include<stdio.h> #include<stdlib.h> #define MAXSIZE 20 #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef char ElemType; typedef int Status; //顺序栈的存储结构 typedef struct { ElemType *base; ElemType *top; int stackSize; } sqSta
2022.03.06快速排序栈溢出
Zack_zc_zc的博客
03-21 708
今天做了一道快速排序的模板题，用的是以前的代码： 但是，出现了栈溢出错误，原因是当原数列是有序时，递归次数太多。现改用另一种代码思路： void qsort(int l, int r) { int tmp = a[(l+r)/2], i = l, j = r; while(i <= j) { while(a[j]>tmp) j--; while(a[i]<tmp) i++; if(i<=j) { int t = a[i]; a[i] = a[j]
数据结构-03-栈
ycmy2017的博客
11-30 563
学习和介绍数据结构之栈
03顺序栈的建立及基本操作
个人练习生
09-20 3068
顺序栈的建立及基本操作 栈的定义 栈是一种只能在一端进行插入和删除操作的线性表。其中允许进行插入和删除操作的一段称为栈顶（Top）。对于顺序栈，就是记录栈顶元素所在数组位置标号的一个整型变量；对于链式栈，就是记录栈顶元素所在节点地址的指针,其中它是动态变化的。表的另一端称为栈底，栈底是固定不变的。栈的插入和删除操作一般称为入栈和出栈。 栈的特点 栈的主要特点就是先进后出（FILO）。...
14.理解线程栈
weixin_40408979的博客
04-29 452
理解线程栈01. 什么是栈02. 在java中设置java线程栈大小03. 栈帧的组成1、局部变量表：2、操作数栈3、帧数据区 01. 什么是栈 java栈是一块线程私有的内存空间 如果说java堆和程序数据密切相关，那么java栈就是和线程执行密切相关的。 线程执行的基本行为是函数调用，每次函数调用的数据都是通过java栈传递的 02. 在java中设置java线程栈大小 -Xss: 设置线程栈大小 大，则系统能支持的线程总数较小 小，则系统容易发生栈溢出 03. 栈帧的组成 1、局部变量
03 利用栈进行中缀表达式计算
qq_59524897的博客
01-18 1598
03 利用栈进行中缀表达式计算
SPT-03-栈.pdf
09-14
栈是一种遵循后进先出（Last-In-First-Out, LIFO）原则的线性数据结构，它只允许在一端进行插入（称为栈顶）和删除操作（也称为弹出）。由于栈的这一特性，它在处理需要逆序操作的问题时非常有效，比如在程序的函数...
山东大学《数据结构》讲义03栈和队列.docx
12-15
山东大学《数据结构》讲义03栈和队列 本资源主要讲解了栈和队列的概念、定义、特性、抽象数据类型、顺序表示与实现、链式表示与实现、应用等方面的知识点。 一、栈和队列概述 从数据结构角度来看，栈和队列是两种...
【IT十八掌徐培成】Java基础第04天-03.OOP-栈区-堆区-引用.zip
08-07
在"Java基础第04天-03.OOP-栈区-堆区-引用.avi"这个视频教程中，IT十八掌徐培成会详细讲解这些概念，通过实例演示如何在实际编程中应用这些知识。学习这些基础知识不仅有助于初学者理解Java的工作原理，也对有经验的...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 3784
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 3832
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 4097
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 2215
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 2310
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
"山东大学《数据结构》讲义03栈和队列.docx；栈和队列的特性与运用
栈和队列是数据结构中的两种特殊线性表，它们的特殊性表现在它们的基本操作是线性表操作的子集，因此可以说它们是限定性的数据结构。从抽象数据类型的角度来看，栈和队列是与线性表不同的两类重要的抽象数据类型。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值