iOS开发学习之C语言---C07 指针-2

//

// main.m

// C07 指针-2

//

// Created by xalo on 15/10/15.

// Copyright (c) 2015年 Darling.com. All rights reserved.

//

#import <Foundation/Foundation.h>

void exchangeNum(int *a,
int *b){

int temp = *a;
*a = *b;
*b = temp;
}

int main(int argc,
const char * argv[]) {

#pragma mark 3.指针与数组

//
定义一个数组

int array[5] = {1,
2, 3,
4, 5};

//
访问数组元素：数组名 + 下标

printf("array[2] = %d\n", array[2]);

//
计算数组元素个数

// 1.计算出数组的总长度

printf("数组的总长度%lu\n",
sizeof(array));

// 2.计算单个元素的字节数

printf("单个元素的字节数%lu\n",
sizeof(array[0]));

// 3.用总长度/单个元素的长度就得出数组元素个数
printf("数组元素个数%lu\n",
sizeof(array) / sizeof(array[0]));

/*

数组名就是数组的首元素地址（数组的首地址），我们可以定义一个指针变量，来存储数组的首地址，这样，指针变量指向的就是这个数组。

*/

//
定义一个指针，将指针指向数组array的首地址

// int *p = array; //
因为数组名array本身就是地址，所以此处不需要取地址符&！！！

// //
下标法访问数组元素：1) 数组名+下标 ;2)
指针 +
下标

// printf("array[0] = %d\n", array[0]);

// printf("p[0] = %d\n", p[0]);

// //
打印指针指向的地址和数组首元素的地址以及数组名指向的地址

// printf("指针指向的地址%p\n", p);

// printf("数组首元素的地址%p\n", &array[0]);

// printf("数组名所保存的地址%p\n", array);

//
数组名和指针的区别

/*

* 指针指向数组的首地址后，可以像数组名一样访问数组元素（数组名/指针+下标）；

* 指针变量的地址可以被修改，但是数组名是一个常量，他所保存的地址不能被修改（数组名不能重指向，但是至真可以重指向）

*/

//
使用指针的方式来访问数组元素

// int temp = *p;

// printf("temp = %d\n", temp);

// int temp1 = *(p+1); //
此时，指针p的指向并没有发生改变，而是产生了一个“新指针（p+1）”指向了数组第二个元素

// printf("temp1 = %d\n", temp1);

//

// //
通过修改指针p的指向，来访问数组元素

// int temp2 = *(++p); //

// printf("temp2 = %d\n", temp2);

// printf("temp2 = %d\n", *(++p));

// temp2 = *(++array);
因为数组名是常量，所以不能通过修改数组名的地址来访问其他元素

// printf("temp2 = %d\n", temp2);

#pragma mark 4.使用指针遍历数组

//
定义一个数组

// int array[5] = {23, 12, 34, 23, 45};

//
定义一个整形指针，让整形数组指向整形数组

// int *p = array;

// for (int i =0; i < 5; i++) {

//// printf("array[%d] = %d\n", i, *(p+i)); // *(p+i)遍历输出

// printf("array[%d] = %d\n", i, *(p++)); // *(p++)遍历输出

// }

//
使用指针实现冒泡排序

/* for (int i = 0; i < 5 - 1; i++) {

for (int j = 0; j < 5 - (1 + i); j++) {

if (*(p+j) > *(p+j+1)) {

int temp = *(p+j) ;

*(p+j) = *(p+j+1);

*(p+j+1) = temp;

}

}

}

for (int i = 0; i < 5; i++) {

printf("%d\n", *(p+i));

}

*/

//
不能使用指针计算数组元素个数，因为指针所占内存的字节数只与操作系统的位数有关！！！

// printf("数组元素个数%lu\n", sizeof(p) / sizeof(p[0])); //这是错误的！！！

#pragma mark 5.指针与字符串

//
定义一个字符数组，用来保存字符串“hello”

char str[] =
"hello";
// 定义了一个数组，系统从常量区（不可修改）把字符串“hello”拷贝到栈区（可以修改），存在数组里，此时可修改！！！

//
定义一个char类型的指针，指向str

char *p = str;

//
使用指针来修改下标为0的元素，改为“a”
*p =
'a';

//
使用指针操作字符串：输出字符串； 使用%s做占位符，参数用指针名，或数组名都可以。

printf("%s\n", p);

printf("%s\n", str);

//
使用指针来遍历字符串

for (int i =
0; i < strlen(str); i++) {

printf("%c\n", *(p+i));
}

//
指针p1此时指向常量区，所以不能修改常量字符串的值。常量字符串，只能访问，不能修改

char *p1 = "abcdefg";
// 常量区

printf("%s\n",p1);

//
总结：指针指向栈区的字符串，可以访问和修改，但是当指针指向常量区时，只能访问，不能修改！

// strcpy(str, p1);

/*通过指针可以计算字符串的长度。

编程实现。

提示:遇到’\0’表⽰示字符串结束。*/

char arr[] = "klklkkl";

char *p2 = arr;

int i = 0;

while (*(p2+i) !=
'\0') {
i++;
}

printf("%d\n", i);

//
通过数组可以计算字符串的长度

// int i = 0;

// while (arr[i] != '\0') {

// i++;

// }

// printf("%d\n", i);

#pragma mark 6.指针数组

// char *p1 = "iOS";

// char *p2 = "iPad";

// char *p3 = "iMac";

//
指针数组，数组中保存的元素都是指针

// strP本质是一维数组，strP数组中存储的是char类型的指针

char *strP[3] = {"iOS",
"iPad", "iMac"};

//
访问

// strP[0],相当于第一个指针，指向iOS的首地址

printf("%s\n", strP[0]);

// strP[1],相当于第二个指针，指向常量区的iPad字符串的首地址

printf("%s\n", strP[1]);

// strP[2],相当于第三个指针，指向常量区的iMac字符串的首地址

printf("%s\n", strP[2]);

//
修改：修改指针数组的元素。在这里，就是修改指针的指向。
strP[0] =
"hello world";

printf("strP[0]指向的地址是：%p\n", strP[0]);

printf("strP[0]的值是：%s\n", strP[0]);

// lianxi:使用指针打印： 1、字符串的地址； 2、一个完整的字符串， 3、字符串中，下标为4的字符

char *p3 =
"hello apple";

printf("%p\n", p3);

printf("%s\n", p3);

printf("%c\n", *(p3 +
4));

#pragma mark 7.指针作为函数的参数

int x = 23,y =
15;

int *k = &x;

int *l = &y;

exchangeNum(k, l);//在函数调用中用了指针作形参，那么调用函数时候实参传递给函数的是参数的地址（即指针k，l）

printf("x = %d, y = %d\n", x, y);

/*指针其实就是地址，例如

int a=3;

int *p=&a;

这时p就是一个指针，它的值就是a在内存中地址，&是取地址的意思，

在函数调用中用了指针作形参，那么调用函数时候实参传递给函数的是参数的地址，函数在执行的过程中会根据这个传过来的地址去对那个变量进行运算。最后会把这个变量的值改变。

用引用也是用地址实现这种传递法。

不用指针变量，则函数在调用时会在内存另外一个地方再开启内存，传递过来的值交给了这个新开启的内存。函数在执行过程中则只对这部分新开启的内存变量操作，结束后不会返回值，

所以，指针变量其实就是通过地址来改变主函数中变量值

*/

return 0;
}