《objective-c程序设计》笔记——C语言相关篇

数组的使用

char letters[5] = {'a','b','c','d','e'};
//如果将[]中的数字隐去，则按照{}中元素的具体数目进行数组分配
char letters[] = {'a','b','c','d','e'};
int numbers[300] = {[9]=1,[3]=7,[1]=29};//任意指定，顺序可以打乱
//如果这里[]中的数字隐去，则默认按照最大的下标来分配数组元素数目，即numbers只有10个元素
int numbers[] = {[9]=1,[3]=7,[1]=29};//任意指定，顺序可以打乱

char word[] = {'H','e','l','l','o','\0'};
NSLog(@"%s",word);
//输出的是“Hello”，因为NSLog会持续显示字符，直到遇到空字符

将函数声明写在文件的开头是一个好习惯，即使调用的函数在前面已经定义，也要尽量把该函数在文件头进行声明一下，这样才能保证编译的正确性。

块（Block）

块定义在函数或者方法的内部，相当于一个简单的内嵌函数，它可以访问块之外函数之内的任意变量

(void)(^printmessage)(void)=
^(void)//括号里面的是传入的参数类型
{
NSLog(@"Hello");
};//不要忘记这个分号
...
...
printmessage();//调用方式不变

#import<Foundation/Foundation.h>

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

int foo = 10;//输出结果为10，说明块方法在定义的时候就已经捆绑了变量的值
__block int foo = 10;//输出结果为15，说明块方法在运行的时候才捆绑变量的值
void(^printFoo)(void)=
^(void)
{
NSLog(@"foo = %i",foo);
};

foo = 15;
printFoo();
}
return 0;
}

#import<Foundation/Foundation.h>

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

__block int foo = 10;//只有定义成块变量，foo才可以在块中更改值

void(^printFoo)(void)=
^(void)
{
NSLog(@"foo = %i",foo);
foo = 20;
};

foo = 15;
printFoo();//输出15
NSLog(@"foo = %i",foo);//输出20
}
return 0;
}

C语言的语法补充

//
//  main.c
//  helloword
//
//  Created by 修宇亮 on 14-7-16.
//  Copyright (c) 2014年 修宇亮. All rights reserved.
//

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

struct student{

int age;
int grade;
char *name;

};

#define SIZE_OF_ARRAY(a) sizeof(a)/sizeof(a[0])
#define HELLO(name) void name##girl(){ \
printf("hello girl"); \
}// \起到续行的作用
#define MYFUNC(name) void name##INIT()

MYFUNC(xyl);
HELLO(xyl);

void xylINIT(){printf("xyl is so cool!");}

一个验证##的实例

#import<Foundation/Foundation.h>

#define INITNAME() {\
printf("Hello xyl1\n");\
}
#define HELLONAME(name) name##hello()//这里不要写上void，会无法连接到xylhello()

void xylhello(){
printf("Hello xyl2\n");
}
int main(int argc, char const *argv[])
{
INITNAME();
HELLONAME(xyl);
return 0;
}

typedef int  long_byte_four;//给数据类型重新命名类型名

int a = 12;
int b = 34;
int *p1 = &a;
int *p2 = &b;

void swap01(int,int);
void swap02(int *,int *);
void swap03(int **,int **);
void swap04(int *,int *);
void testmalloc();
void testcalloc();
void testrealloc(int *);
void testvoid();
void test_type_rename();
void test_byte();
void test_pointer();
void test_pointer_func();
void test_pointer_string();
void test_struct();
void common_swap();
void hong();
void swap(void *,void *,int );

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

test_byte();//测试每一种数据类型的字节数
test_type_rename();//测试数据类型重新命名类型名
test_pointer();//测试指针的用途
test_pointer_func();//指针函数和函数指针
test_pointer_string();//字符串数组和指针字符串
test_struct();

//四种交换算法（原数，地址，指针）
swap01(a, b);
swap02(&a, &b);
swap03(&p1, &p2);
swap04(p1, p2);

testmalloc();//malloc分配单块内存空间函数
testcalloc();///calloc连续分配内存空间函数
testrealloc(p2);//realloc重新定义内存分配空间的函数

common_swap();
hong();

return 0;
}

//可以被普遍使用的泛型swap

void swap(void *p1,void *p2,int size){

char *charat1 = (char *)p1;
char *charat2 = (char *)p2;

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

int temp;
temp = *(charat1+i);
*(charat1+i) = *(charat2+i);
*(charat2+i) = temp;

}

}

//void型变量的通用特性
void testvoid(){

int *t1 = NULL;
int a = 1;
t1 = &a;
void *v1 = NULL;
v1 = t1;

long *t2 = NULL;
long b = 78687698679867;
t2 = &b;
void *v2 = NULL;
v2 = t2;

printf("v1 = %d\n",*(int *)v1);
printf("v2 = %ld\n",*(long *)v2);

}

malloc, calloc,realloc之间的区别

void realloc(void ptr, unsigned newsize);

void malloc(unsigned size);

void calloc(size_t nelem, size_t elsize);

都在stdlib.h函数库内

它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL

malloc用于申请一段新的地址,参数size为需要内存空间的长度,如:

char p;

p=(char)malloc(20);

calloc与malloc相似,参数elsize 为申请地址的单位元素长度,nelem为元素个数,如:

char p;

p=(char)calloc(20, sizeof(char));

这个例子与上一个效果相同

realloc是给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度

如:

char p;

p=(char)malloc(sizeof(char)20);

p=(char)realloc(p,sizeof(char)*40);

注意，这里的空间长度都是以字节为单位。

C语言的标准内存分配函数：malloc，calloc，realloc等。

malloc与calloc的区别为1块与n块的区别：

malloc调用形式为(类型)malloc(size)：在内存的动态存储区中分配一块长度为“size”字节的连续区域，返回该区域的首地址。

calloc调用形式为(类型)calloc(n，size)：在内存的动态存储区中分配n块长度为“size”字节的连续区域， 每一位都初始化为零，返回首地址。

realloc调用形式为(类型)realloc(ptr，size)：将ptr内存大小增大到size。

free的调用形式为free(void*ptr)：释放ptr所指向的一块内存空间。

C++中为new/delete函数。

//malloc分配单块内存空间函数
void testmalloc(){

//对p的单帧并没有清零，数值为随机数
int *p = malloc(sizeof(int));
if(p != NULL){
*p = 1234;

}else{
exit(1);
}

printf("*p = %d\n",*p);
free(p);
p = NULL;
}

//calloc连续分配内存空间函数
void testcalloc(){

//对p的每一帧都实现清零
int *p = calloc(5, sizeof(int));
if(p !=NULL){
for(int i=0;i<5;i++){
*(p+i) = i+2;
printf("*p = %d\n",*(p+i));
}
}else{
exit(1);
}

testrealloc(p);
p = NULL;

}

//realloc重新定义内存分配空间的函数
void testrealloc( int *p2){

int *re_p = realloc(p2, 10);
if(re_p !=NULL){

for(int i=5;i<10;i++){
*(re_p+i) = i+2;
}
for(int i=0;i<10;i++){
printf("*re_p = %d\n",*(re_p+i));
}
}else{
exit(1);
}
free(re_p);
re_p = NULL;
p2 = NULL;

}

void test_type_rename(){
long_byte_four a1 = 123;
printf("a1 == %d\n",a1);
}

int add(int a,int b){
return a+b;
}

int multiple(int (*func)(int,int),int n1,int n2){
return func(n1,n2)*n1;
}

//测试通用性交换算法
void common_swap(){

int a = 123;
int b = 456;

char ch1[] = "xiuyuliang";
char ch2[] = "wangruihah";

swap(&a,&b,sizeof(a));

printf("a = %d\n",a);
printf("b = %d\n",b);

swap(ch1, ch2, sizeof(ch1));
printf("ch1 = %s\n",ch1);
printf("ch2 = %s\n",ch2);

}

void swap01(int t1,int t2){

printf("最原始的纯数据交换(a,b)\n");
printf("a = %d\n",a);
printf("b = %d\n",b);

int temp;
temp = t1;
t1 = t2;
t2 = temp;

printf("a = %d\n",a);
printf("b = %d\n",b);

}

void swap02(int *t1,int *t2){

//swap02(&a, &b);

printf("仅仅交换副本指针的地址(&t1,&t2)\n");
printf("a = %d\n",a);
printf("b = %d\n",b);

int *temp = NULL;
temp = t1;
t1 = t2;
t2 = temp;
printf("a = %d\n",a);
printf("b = %d\n",b);
printf("t1 = %d\n",*t1);
printf("t2 = %d\n",*t2);

}

void swap03(int **t1,int **t2){

// swap03(&p1, &p2);

printf("真正交换了原始指针(p1,p2)\n");
printf("a = %d\n",a);
printf("b = %d\n",b);

int *temp = NULL;
temp = *t1;
*t1 = *t2;
*t2 = temp;

printf("a = %d\n",a);
printf("b = %d\n",b);
printf("t1 = %d\n",**t1);
printf("t2 = %d\n",**t2);

}

void swap04(int *t1,int *t2){

//swap04(p1, p2);
printf("真正交换了原值(a,b)\n");
printf("a = %d\n",a);
printf("b = %d\n",b);

int temp ;
temp = *t1;
*t1 = *t2;
*t2 = temp;

printf("a = %d\n",a);
printf("b = %d\n",b);

}

void test_byte(){

printf("char_byte === %ld\n" ,sizeof(char));
printf("int_byte === %ld\n" ,sizeof(int));
printf("long_byte === %ld\n" ,sizeof(long));
printf("short_byte === %ld\n" ,sizeof(short));
printf("double_byte === %ld\n" ,sizeof(double));
printf("long double_byte === %ld\n" ,sizeof(long double));
}

//测试指针的用途
void test_pointer(){

int a = 123;
int *b = &a;
int **c = &b;

printf("a = %d\n",a);//a的值
printf("&a = %p\n",&a);//a的地址
printf("b = %p\n",b);//b存的a的地址
printf("&b = %p\n",&b);//b的地址
printf("*b = %d\n",*b);//b存的地址解码为a的值
printf("c = %p\n",c);//c存的b的地址
printf("*c = %p\n",*c);//c存的b的地址解码为b的值，即a的地址
printf("**c = %d\n",**c);//c解码两次，第一次解码为b的值，即a的地址，第二次解码为a的值，为123
printf("&c = %p\n",&c);//c的地址
}

//指针函数和函数指针
//指针函数和函数指针的主要用途是作为参数传入函数或者方法
void test_pointer_func(){

int add(int ,int);
int (*pfunc)(int a,int b);
pfunc = add;
int result = pfunc(13,12);
printf("a+b ==  %d\n",result);

int multiple(int (*func)(int,int),int n1,int n2);
int result2 = multiple(add, 5, 3);
printf("(a+b)*a = %d\n", result2);
}

//字符串数组和指针字符串
void test_pointer_string(){

char ch1[] = "success";
char *ch2 = "success2";
char *ch3 = "success3";
char *ch2_copy = "success2";

printf("ch1 = %s\n",ch1);
printf("ch1的地址 = %p\n",ch1);
printf("ch2 = %s\n",ch2);
printf("ch2的地址 = %p\n",ch2);
printf("ch2_copy的地址 = %p\n",ch2_copy);
printf("ch3 = %s\n",ch3);
printf("ch3的地址 = %p\n",ch3);

}

//测试结构体输出

void test_struct(){
struct student *s1 = malloc(sizeof(struct student));
if(s1 !=NULL){

s1->age = 23;
s1->grade = 8;
s1->name = "xyl";

printf("s1.age = %d\n",s1->age);
printf("s1.grade = %d\n",s1->grade);
printf("s1.name = %s\n",s1->name);

}else{
exit(1);
}

free(s1);
s1 = NULL;

}

//检测宏定义的输出
void hong(){

int a[] = {1,23,45,9,23,89};

printf("array_size = %ld\n",SIZE_OF_ARRAY(a));
printf("%d\n",__LINE__);
printf("%s\n",__FILE__);
printf("%s\n",__TIME__);
printf("%s\n",__DATE__);
printf("%d\n",__STDC__);
xylINIT();
xylgirl();

}

小细节语法点

int x =123;
int a[] = {[7]=1,[0]=x+1,[4]=5};//针对性的设置数组中的特定数值，其余为0

char ch1[80] = "nihao woshi nidie";
char *ch2 = "nihao woshi nidei";
//这两个都可以运行顺利，但是意义不同，一个是表示一段内存区域的数值分配，另一个是引用一个指针指向一个字符数组

//空语句的功能
//功能是将键盘输入的字符存储到test指针指向的内存空间
while((*test = getchar()) != '')
;//空语句

//goto语句，实际上是一种执行跳转语句，直接跳转到goto后面标签标注的语句
//这是一种很不好的编程习惯，不利于他人对程序的理解
goto out_of_data;
...
...
...
out_of_data: NSLog(@"out of data");

int arraySum(int array[], int n)
int *arrayEnd = array+n;
//这里面虽然写的是arrgy[]，但其实传入之后的array其实是一个地址，而且是数组的首地址

//一个例子说明这个问题
#import<Foundation/Foundation.h>

int arraySum(int array[], int n)
{
int *pr,*arrayEnd;
int sum = 0;
arrayEnd = array + n;

for(pr=array;pr<arrayEnd;pr++)
{
sum += *pr;
}

return sum;
}

int main(int argc, char const *argv[])
{
@autoreleasepool
{
int value[10] = {1,2,3,4,5,6,7,8,9,10};
NSLog(@"The sum is %i",arraySum(value,10));
return 0;
}

}

void NSLog(NSString *format,...);//...用途是声明参数有不定数目

块（BLOCK）

#import <Foundation/Foundation.h>

void (^calculateTriangleNumber)(int) =
^(int n)
{
int triangleNumber = 0;
for(int i=1;i<=n;i++)
{
triangleNumber += i;
}

NSLog(@"The triangleNumber of %i is %i",n,triangleNumber);
};//分号一定不要忘记，因为这是一个句子

int main(int argc,char *argv[])
{
@autoreleasepool
{
calculateTriangleNumber(10);
calculateTriangleNumber(20);
calculateTriangleNumber(50);
}
return 0;
}

结构体的相互借用

```
#import <Foundation/Foundation.h>

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

@autoreleasepool{

struct CGPoint
{
CGFloat x;
CGFloat y;
};

typedef struct CGPoint CGPoint;

struct CGSize
{
CGFloat width;
CGFloat height;
};

typedef struct CGSize CGSize;

struct CGRect
{
CGPoint origin;
CGSize  size;
};

typedef struct CGRect CGRect;
CGRect  rect1 ;
CGPoint startp;
CGSize  range;

startp.x = 100.0;
startp.y = 200.0;

range.width = 20.0;
range.height = 40.0;

rect1.origin = startp;
rect1.size = range;

NSLog(@"The rectangle :\n");
NSLog(@"width: %f",rect1.size.width);
NSLog(@"height: %f",rect1.size.height);
NSLog(@"origin: (%f,%f)",rect1.origin.x,rect1.origin.y);
}

return 0;

}

```

结构体声明变量的方法

//在结构体中声明多个变量
struct date
{
int year;
int month;
int day;
}today,tomorrow;

//直接在结构体中声明定义变量
struct date
{
int year;
int month;
int day;
}today = {2013,2,4};

struct today = {2014,1,21};
//直接的初始化方式
struct today = {.month = 2,.year = 1,.day = 21};
//可以打乱方式用.member = value赋值

//定义100天
struct
{
int year;
int month;
int day;
}date[100];