头哥c语言malloc

malloc是C语言中用于动态分配内存的函数，其原型如下：

void* malloc(size_t size);

该函数接受一个参数size，表示需要分配的内存大小，返回值为void指针，指向分配的内存空间的起始地址。如果分配失败，则返回NULL。

以下是一个使用malloc动态分配内存的例子：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n, i, sum = 0;

    printf("Enter number of elements: ");
    scanf("%d", &n);

    ptr = (int*) malloc(n * sizeof(int)); // 动态分配内存

    if (ptr == NULL) { // 判断是否分配成功
        printf("Memory allocation failed!");
        exit(0);
    }

    printf("Enter elements: ");
    for (i = 0; i < n; i++) {
        scanf("%d", ptr + i);
        sum += *(ptr + i);
    }

    printf("Sum = %d", sum);

    free(ptr); // 释放内存

    return 0;
}

相关问题

c语言指针进阶 头哥

C语言指针进阶主要包括以下几个方面：

1.指针的指针：指针的指针是指一个指针变量的地址，即一个指向指针变量的指针。可以通过指针的指针来修改指针变量的值。例如：

int a = 10;
int *p = &a;
int **pp = &p;
**pp = 20;
printf("%d", a); // 输出：20

2.指针数组：指针数组是一个数组，其中的每个元素都是一个指针。可以通过指针数组来存储多个指针变量的地址。例如：

int a = 10, b = 20, c = 30;
int *p[3] = {&a, &b, &c};
for (int i = 0; i < 3; i++) {
    printf("%d ", *p[i]);
}
// 输出：10 20 30

3.动态内存分配：动态内存分配是指在程序运行时根据需要动态地分配内存空间。可以使用malloc函数来动态分配内存空间，使用free函数来释放内存空间。例如：

int n;
scanf("%d", &n);
int *p = (int*)malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
    scanf("%d", &p[i]);
}
for (int i = 0; i < n; i++) {
    printf("%d ", p[i]);
}
free(p);

4.指针和字符串：字符串在C语言中是以字符数组的形式存储的，可以使用指针来操作字符串。例如：

char str[] = "hello world";
char *p = str;
while (*p != '\0') {
    printf("%c", *p);
    p++;
}
// 输出：hello world

中缀表达式转换为后缀表达式（栈-链栈）（c语言）（头哥适用版）

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

typedef struct Node {
char data;
struct Node *next;
} Node, *LinkStack;

// 初始化链栈
void initStack(LinkStack *s) {
*s = NULL;
}

// 判断栈是否为空
int isEmpty(LinkStack s) {
return s == NULL;
}

// 入栈
void push(LinkStack *s, char data) {
Node *node = (Node *) malloc(sizeof(Node));
node->data = data;
node->next = *s;
*s = node;
}

// 出栈
char pop(LinkStack *s) {
if (isEmpty(*s)) {
printf("Stack is empty!\n");
exit(-1);
}
char data = (*s)->data;
Node *temp = *s;
*s = (*s)->next;
free(temp);
return data;
}

// 获取栈顶元素
char getTop(LinkStack s) {
if (isEmpty(s)) {
printf("Stack is empty!\n");
exit(-1);
}
return s->data;
}

// 判断运算符优先级
int getPriority(char op) {
switch (op) {
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
case '(':
return 0;
default:
printf("Invalid operator!\n");
exit(-1);
}
}

// 中缀表达式转换为后缀表达式
void infixToPostfix(char *infix, char *postfix) {
LinkStack s;
initStack(&s);
int i = 0, j = 0;
while (infix[i] != '\0') {
if (isdigit(infix[i])) { // 如果是数字，直接输出到后缀表达式中
postfix[j++] = infix[i++];
} else if (infix[i] == '(') { // 如果是左括号，入栈
push(&s, infix[i++]);
} else if (infix[i] == ')') { // 如果是右括号，弹出栈中左括号之前的运算符并输出到后缀表达式中
while (getTop(s) != '(') {
postfix[j++] = pop(&s);
}
pop(&s); // 弹出左括号
i++;
} else if (infix[i] == '+' || infix[i] == '-' || infix[i] == '*' || infix[i] == '/') { // 如果是运算符
if (isEmpty(s) || getPriority(infix[i]) > getPriority(getTop(s))) { // 如果栈为空或当前运算符的优先级大于栈顶运算符的优先级，入栈
push(&s, infix[i++]);
} else { // 弹出栈中优先级大于等于当前运算符的运算符并输出到后缀表达式中，然后把当前运算符入栈
postfix[j++] = pop(&s);
}
} else { // 如果是非法字符，输出错误信息并退出程序
printf("Invalid character!\n");
exit(-1);
}
}
while (!isEmpty(s)) { // 把栈中剩余的运算符依次弹出并输出到后缀表达式中
postfix[j++] = pop(&s);
}
postfix[j] = '\0'; // 加上字符串结束符
}

int main() {
char infix[50], postfix[50];
printf("请输入中缀表达式：");
gets(infix);
infixToPostfix(infix, postfix);
printf("后缀表达式为：%s\n", postfix);
return 0;
}