用指针实现一个基础功能

使用指针实现一个基础功能的一个常见例子是交换两个变量的值，这不需要创建额外的临时变量。我们可以利用指针来间接操作内存地址，达到交换的目的。以下是使用C语言的示例：

#include <stdio.h>

// 定义一个函数，接受两个整数的指针作为参数
void swap(int* a, int* b) {
    // 创建一个新的临时指针，指向a的值
    int temp = *a;
    
    // 将a指向b的值
    *a = *b;
    
    // 将b指向temp（即原来的a的值）
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    printf("Before swapping: x = %d, y = %d\n", x, y);

    // 调用swap函数，传入x和y的地址
    swap(&x, &y);
    
    printf("After swapping: x = %d, y = %d\n", x, y);
    return 0;
}

在这个例子中，`&x` 和 `&y` 分别获取了变量 `x` 和 `y` 的内存地址，通过指针操作实现了它们值的交换。运行这个程序后，你会发现 `x` 和 `y` 的值已经被互换。

相关问题

使用c++语言用类方法指针自定义一个栈，实现栈的基本功能

好的，我来给您提供一个基于指针实现的栈的类方法的示例代码，包括插入和删除功能：

#include <iostream>

using namespace std;

class Stack {
private:
    struct Node {
        int data; // 存储数据的变量
        Node *next; // 指向下一个节点的指针
    };

    Node *topNode; // 指向栈顶节点的指针

public:
    Stack() {
        topNode = nullptr; // 初始化栈顶指针为nullptr
    }

    bool isEmpty() {
        return topNode == nullptr; // 栈顶指针为nullptr代表栈为空
    }

    bool push(int value) {
        Node *node = new Node; // 创建一个新节点
        node->data = value; // 将元素存储到新节点的data变量中
        node->next = topNode; // 将新节点的next指针指向栈顶节点
        topNode = node; // 将栈顶指针指向新节点
        return true; // 插入成功
    }

    bool pop() {
        if (isEmpty()) {
            return false; // 栈为空，删除失败
        }
        Node *node = topNode; // 将栈顶指针赋值给一个临时变量
        topNode = topNode->next; // 将栈顶指针指向下一个节点
        delete node; // 删除栈顶节点
        return true; // 删除成功
    }

    int top() {
        if (isEmpty()) {
            return -1; // 栈为空，返回-1
        }
        return topNode->data; // 返回栈顶节点的data变量
    }
};

int main() {
    Stack s;

    s.push(1);
    s.push(2);
    s.push(3);

    while (!s.isEmpty()) {
        cout << s.top() << endl;
        s.pop();
    }

    return 0;
}

在这个代码中，我们定义了一个 `Stack` 类，其中包含了 `Node` 结构体、`topNode` 栈顶指针、`isEmpty`、`push`、`pop`、`top` 函数。我们可以通过 `Stack` 类中的对象来创建一个栈，并使用 `push` 函数插入元素，使用 `pop` 函数删除元素，使用 `top` 函数获取栈顶元素。

在 `Node` 结构体中，我们定义了 `data` 存储数据的变量和 `next` 指向下一个节点的指针。

在 `isEmpty` 函数中，我们判断栈顶指针是否为nullptr，如果是，则栈为空，返回 `true`，否则返回 `false`。

在 `push` 函数中，我们创建一个新的节点，并将元素存储到该节点的 `data` 变量中，将该节点的 `next` 指针指向栈顶节点，将栈顶指针指向该节点，返回 `true`。

在 `pop` 函数中，我们首先判断栈是否为空，如果是，则删除失败，返回 `false`，否则将栈顶指针赋值给一个临时变量 `node`，将栈顶指针指向下一个节点，删除 `node` 节点，返回 `true`。

在 `top` 函数中，我们首先判断栈是否为空，如果是，则返回-1，否则返回栈顶节点的 `data` 变量。

在 `main` 函数中，我们创建了一个 `Stack` 类型的对象 `s`，并使用 `push` 函数插入三个元素，使用 `top` 函数获取栈顶元素并输出，使用 `pop` 函数删除栈顶元素。最终，我们将栈中的所有元素输出。

实现一个链栈及基本功能

链栈是一种基于链表实现的栈，其基本功能包括入栈、出栈、查看栈顶元素、判断栈是否为空等。下面是一个基于Python语言实现的链栈及其基本功能：

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedStack:
    def __init__(self):
        self.top = None # 栈顶指针

    def is_empty(self):
        return self.top is None # 判断栈是否为空

    def push(self, data):
        new_node = Node(data)
        new_node.next = self.top
        self.top = new_node # 入栈操作

    def pop(self):
        if self.is_empty():
            print("Stack is empty!")
            return None
        data = self.top.data
        self.top = self.top.next
        return data # 出栈操作

    def peek(self):
        if self.is_empty():
            print("Stack is empty!")
            return None
        return self.top.data # 查看栈顶元素

    def print_stack(self):
        if self.is_empty():
            print("Stack is empty!")
            return
        node = self.top
        while node:
            print(node.data, end=" -> ")
            node = node.next # 打印栈中所有元素
        print("NULL")

可以通过以下代码进行测试：

stack = LinkedStack()
print(stack.is_empty()) # True
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.peek()) # 3
stack.print_stack() # 3 -> 2 -> 1 -> NULL
stack.pop()
print(stack.peek()) # 2
stack.print_stack() # 2 -> 1 -> NULL

以上代码实现了链栈的入栈、出栈、查看栈顶元素、判断栈是否为空等基本功能。