猜数赌博游戏
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int cash = 100;
void play(int bet) {
char c[3] = { 'j','q','k' };
printf("shuffling...\n");
srand(time(NULL));
int i;
for (i = 0; i < 5; i++) {
int x = rand() % 3;
int y = rand() % 3;
int temp = c[x];
c[x] = c[y];
c[y] = temp;
}
int playersguess;
printf("what's the position of queen -1,2 or 3");
scanf_s("%d",&playersguess);
if (c[playersguess - 1] == 'q') {
cash += 3 * bet;
printf("You win ! result = %c%c%c total cash = %d", c[0], c[1], c[2],cash);
}
else {
cash -= bet;
printf("You loose ! result = %c%c%c total cash = %d",c[0],c[1],c[2],cash);
}
}
int main() {
int bet;
while (cash > 0) {
printf("what's your bet?$ ");
scanf_s("%d",&bet);
if (bet == 0 || bet > cash)break;
play(bet);
}
}转变为使用malloc函数，调用堆
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int cash = 100;
void play(int bet) {
//char c[3] = { 'j','q','k' };
char *c = (char*)malloc(3*sizeof(char)); //c++中 char *c = new char[3];
char[0] ='j';char[1] = 'q';char[2] = 'k';
printf("shuffling...\n");
srand(time(NULL));
int i;
for (i = 0; i < 5; i++) {
int x = rand() % 3;
int y = rand() % 3;
int temp = c[x];
c[x] = c[y];
c[y] = temp;
}
int playersguess;
printf("what's the position of queen -1,2 or 3");
scanf_s("%d",&playersguess);
if (c[playersguess - 1] == 'q') {
cash += 3 * bet;
printf("You win ! result = %c%c%c total cash = %d", c[0], c[1], c[2],cash);
}
else {
cash -= bet;
printf("You loose ! result = %c%c%c total cash = %d",c[0],c[1],c[2],cash);
}
//free(c);
}
int main() {
int bet;
while (cash > 0) {
printf("what's your bet?$ ");
scanf_s("%d",&bet);
if (bet == 0 || bet > cash)break;
play(bet);
}
}
这时不使用free（）函数，堆中占用的内存不会被释放，会造成内存泄漏
#include <stdio.h>
#include <stdlib.h>
void printHelloworld() {
printf("hello world!\n");
}
int *add(int* a, int* b) {
int sum = (*a) + (*b);
return ∑
}
int main()
{
printHelloworld();
int x = 10, y = 20;
int* sum = add(&x,&y);
printHelloworld();
printf("%d",*sum);
}
出现上述问题时，可以这样改
int* c= (int* )malloc(sizeof(int));
*c = (*a)+(*b);
return c;指针中函数的调用
#include <stdio.h>
int add(int a,int b) {
return a + b;
}
int main() {
int c;
int (*p)(int, int);
//如果（*p）不加括号，那么意味着是在声明一个函数，返回一个整形指针
//int *func(int,int);
//但如果我添加了括号，则说明我是返回了一个函数指针
p = &add;
/*这里使用了取地址符&，但就算不使用，它的含义也是一样的，只是用函数名也会返回函数的地址
换句话说，一个恰当的指针，解引用的时候作为替代，我们也可以直接使用函数指针名，因此我们可以
使用函数指针名,我们使用函数指针名就像使用函数名一样，仍然可以符合我们的预期
*/
c = (*p)(2, 3);
//例如这里 c = p(2,3);
printf("%d",c);
}需要明确的是，为了指向一个函数，函数指针的类型必须是正确的
例如
初始化函数，然后给出地址，就可以通过指针来访问函数了
排序问题
#include<stdio.h>
int compare(int a, int b) {
if (a > b)
return 0;
else return 1;
}
void BubbleSort(int *A, int n, int (*compare)(int, int)) {
int i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < n-1; j++) {
if(compare(A[j], A[j + 1] )) {
// if((*compare)(*A+j),(*A+j+1)) 这里用到指针
temp = A[j];
A[j] = A[j+1];
A[j+1] = temp;
}
}
}
}
int main()
{
int i, A[] = { 2,3,1,5,7,6 };
BubbleSort(A, 6, compare);//这里函数名就是指针
for (i = 0; i < 6; i++) {
printf("%d ", A[i]);
}
return 0;
}指针回调函数的例子
#include<stdio.h>
void A() {
printf("hello");
}
void B(int(* ptr)()) {
ptr();
}
int main() {
void(* p)() = A;//因为这里调用的是指针函数，要写明返回值 以及参数类型
B(p);
}绝对值 
包含在stdlib.h函数中的qsort函数，可以接收任意数组
qsort代表quick sort，你应该向这个函数传入一个数组，一个任意数组，可以是整型的或是字符型的，甚至复杂的数据类型，一个结构体，第一个参数是数组，第二个参数是数组中元素的数量，第三个参数是数据类型的大小，最后一个参数是函数指针，比较函数的指针，比较函数看起来像这样
void 指针是通用的指针类型，我们可以转换为任意类型
qsort函数接收一个指向这种函数类型的指针，这样就能回调这个比较函数了
快排函数
原理就只有一个，就是操作返回值
两个形参，分别是a, b;
qsort() 会看返回值；
如果 a - b 与 你设置的返回值 同号， 就是递增， 例 return *(int *) a - *(int *) b; 和 return strcmp((char *) a, (char *) b); 都是 a - b 与 设置的返回值 的同号的。
如果 a - b 与 你设置的返回值 异号， 就是递减， 例 return *(int *)b - *(int *) a; 和 return -strcmp((char *) a, (char *) b);
————————————————
原文链接：https://blog.csdn.net/dongdongzhang_/article/details/7961208
指针 *（ptr+2）的意思是 ptr=ptr+2*sizeof（int）
