函数

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//参数传值调用

在C语言中,被调函数不能直接修改主调函数中变量的值,而只能修改函数私有的临时副本的值

必要时,也能够修改主调函数中的变量。需要向被调用函数提供待设置值的变量的地址(指针)。被调用函数则需要将对应的参数声明为指针类型,并通过它间接访问变量。

如果是数组参数,当把数组名用作参数时,传递给函数的值是数组起始元素的位置或地址,并不复制数组元素的本身。在被调函数中,可以通过数组下标访问或修改数组元素的值。

————————————————————————————————————————————

变量

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

自动变量(局部变量) //在一个函数开头或段开头处说明的变量

作用域:

仅在定义它的函数内;

初始化:

不自动赋初值,使用前需要赋值;

值的保持:

随函数的引用而存在和消失,不保持值;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

外部变量(全程变量) //在函数外部定义的变量

优势:解决函数单独编译的协调;与变量初始化有关;外部变量的值是永久的;解决数据共享;

作用域:整个程序;

初始化:0;

值的保持:永久保持

特点:

  1. c程序可以分别放在几个文件上,每个文件可以作为一个编译单位分别进行编译。外部变量只需在某个文件上定义一次,其它文件若要引用此变量时,应用extern加以说明(外部变量定义时不必加extern关键字)
  2. 在同一文件中,若前面的函数要引用后面定义的外部(在函数之外)变量时,在函数里加extern加以说明。

举例:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

静态变量 - 内部 //在局部变量前加上static

作用域:仅在定义它的函数内;

初始化:0;

值的保持:当函数执行完,返回调用点时,该变量并不撤销,再次调用时,其值将继续存在;

特点:采用静态存贮分配(由编译程序在编译时分配,而一般的自动变量和函数形参均采用动态存贮分配,即在运行时分配空间);

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

静态变量 - 外部 //在函数外部定义的变量前加static

优势:可以实现数据隐藏

作用域:定义它的文件(该文件的私有变量),其他文件上的函数不允许访问;

初始化:0;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

寄存器变量 //只有自动(局部)变量和函数参数才能进一步指定为寄存器存贮类

特点:

  1. 使用register变量可以提高存取速度,但寄存器变量的数目依赖于具体机器,声明多了也只有前几个有效。
  2. 只限于int,char,short ,unsigned和指针类型用寄存类。
  3. 不能对register变量取地址(即&操作)

————————————————————————————————————————————

常量

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

enum 枚举常量

不同枚举中的名字必须互不相同,同一枚举中不同的名字可以是用相同的值;相对#define来说,优势在于常量值可以自动生成

举例:

  1. enum week {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};

    /*

    week是新的数据类型,源于int,此时:

    MONDAY = 0

    TUESDAY = 1

    WEDNESDAY = 2

    THURSDAY = 3

    FRIDAY = 4

    SATURDAY = 5

    SUNDAY = 6

    */

  2. enum week {MONDAY = 1, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};

    /*

    MONDAY = 1

    TUESDAY = 2

    WEDNESDAY = 3

    THURSDAY = 4

    FRIDAY = 5

    SATURDAY = 6

    SUNDAY = 7

    */

  3. enum escapes {BELL = '\a', BACKSPACE = '\b', TAB = '\t', NEWLINE = 'n', VTAB = '\v', RETURN = '\r'};

    /*

    BELL = '\a',

    BACKSPACE = '\b',

    TAB = '\t',

    NEWLINE = 'n',

    VTAB = '\v',

    RETURN = '\r'

    */

————————————————————————————————————————————

关键字

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

const //限定符,通过 const 对变量进行限定后,无法修改其值,数组同理。

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

register //请求编译器尽可能的将变量存在CPU内部寄存器中,而不是通过内存寻址访问,以提高效率。

  1. register变量必须是能被CPU所接受的类型。这通常意味着register变量必须是一个单个的值,并且长度应该小于或者等于整型的长度。
  2. 不能通过 & 来取地址

————————————————————————————————————————————

数组

注意:数组名即数组的第一个元素的地址,所以使用scanf函数的时候可以不使用 &

// 调用数组a[i]的值时也可以写成 *(a+i) 的形式,编译的过程实际上先将其转换成 *(a+i) 再求值。所以 a[i] 与 *(a+i) 是等价的,一个通过数组和下表实现的表达式可以通过指针可偏移量实现。注意:指针是一个变量, p=a或p++是合法的,但数组名不是变量,不可以执行上面的操作。

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

字符数组 //scanf在读取字符串的时候不使用取址操作符 &,同指针

char str[1000];

scanf("%s",str);

————————————————————————————————————————————

指针

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

地址运算符 & 只能应用于内存中的对象(变量与数组元素)。它不能作用于表达式/常量/register类型的变量。

取值运算符 * ,在定义指针时表示定义的是个变量,在其他地方表示取指针变量的那个值

指针只能指向某种特定类型的对象(例外情况:指向void类型的指针可以存放指向任何类型的指针,但它不能间接引用其自身)。

定义:

int a;

int *p;

p = &a;

scanf("%d",p);

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

//指向数组的普通指针(非数组指针)

#include <stdio.h>

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

{

//char

char *p;//定义一个字符指针

char str[1000];//定义一个字符数组

scanf("%s", str);//字符数组输入

p = str; //p指针指向str首地址

printf("%c %c\n", *p, *(p + 1)); //打印首地址的值与第二个地址的值

//int

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

int *q;

q = a;

//或写成 int *q = a;

printf("%d %d\n", *q, *(q + 1));

return 0;

}

//指向指针的指针

定义:

#include <stdio.h>

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

{

int num = 520;

int *p = &num;

int **pp = &p;//pp为指向指针的指针

return 0;

}

num

p

&num

//指针p中存放的是num的地址

*p

num

//对指针p解引用得到&num存放的值 == 520

pp

&p

//pp作为指向指针p的指针,存放的是p的地址

*pp

p

&num

//pp解引用得到的是 p == &num

**pp

*p

num

//对pp二层解引用得到的是 *p == num ==520

举例:

#include <stdio.h>

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

{

char *str[] = {"aaa", "bbb", "ccc", "ddd", "eee", "fff"};

//定义这个指针数组,此时指针数组存放的都是指针,字符串是指向字符的指针,数组每个元素都是指针,数组又可以用指针的方式来访问,所以我们可以用指向指针的指针来访问指针数组;

char **p;//定义指针p为指向指针的指针

个指向指针的指针

p = &str[5];//p指向"fff",取址得到字符串"fff"的地址,此时p的一个指向字符指针的指针

str2[0] = &str[0];//str2数组中的指向指针的指针分别指向str数组中的指针

str2[1] = &str[1];

str2[2] = &str[2];

str2[3] = &str[3];

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

for (int i = 0; i < 4; ++i)

{

printf("%s\n", *str2[i]);

}

return 0;

}

//指向常量的指针 (指针本身可以被修改)

//const int *p可以指向const int 和int,但都不可以通过*p赋值

#include <stdio.h>

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

{

int num = 520;

const int cnum = 820;

const int *p = &cnum;

printf("%d %d\n", &cnum, cnum);

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

p = &num;

//*p=1024; 此条无法通过编译,*p read-only

num = 1024;

return 0;

}

//常量指针 (指针本身不可以被修改)

//int * const p定义了指向之后,无法指向其他量

//指向非常量的常量指针:指向的值可以被修改

//指向常量的常量指针:指向的值不可以被修改

//cmd下无法被编译,unix和codeblocks可以编译

#include <stdio.h>

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

{

int num = 520;

const int cnum = 820;

int *const p =&cnum;

*p = 1024;

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

//p=&cnum; 常量指针指向num后,不可以修改指向

return 0;

}

//指向"指向常量的常量指针"的指针

#include <stdio.h>

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

{

int num = 520;

const int cnum = 820;

const int *const p = &cnum;//定义一个指向常量的常量指针

const int *const *pp = &p;//定义一个指向"指向常量的常量指针"的指针

printf("%p %p\n", pp, &p);//打印p的地址,pp和&p相同

printf("%p %p %p\n", *pp, p, &cnum);//打印num的地址,*pp和p和&num相同

printf("%d %d %d\n", **pp, *p, cnum);

return 0;

}

//参数指针

语法:double atof(char *);

/* atof的参数时一个指向char类型的指针*/

//void指针

将任意类型的指针可以转换成为void指针;

但是void指针转化为其他类型需要使用强制转换;

#include <stdio.h>

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

{

int num = 1234;

int *pi = &num;

char *ps = "abcd";

void *pv;

pv = pi; //pv变成指向整型的指针;

printf("%p %p\n", pi, pv); //两个指针分别的地址;

//printf("%d\n", *pv);//尝试解引用一个void指针,不知道void类型的宽度,编译器无法直接完成

printf("%d\n", *(int *)pv); //将pv强制转换成为int类型的指针,并解引用

pv = ps;

printf("%p %p\n", ps, pv);

//printf("%s\n", pv);//字符串只需要指向首字符的地址就可以了,但是这样写是不规范的

printf("%s\n",(char *)pv);

return 0;

}

#include <stdio.h>

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

{

int *p1; //p1成为迷途指针,悬空指针,即没有指定的指针

int *p2 = NULL;

printf("%p %p\n", p1, p2);

printf("%d %d\n", *p1, *p2); //unix下编译得到 *p1的值是随机的,*p2返回segmentation fault,因为对NULL指针解引用是非法的,程序崩溃报错

return 0;

}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

指针运算

// *ip自增

语法:

  1. *ip += 1;
  2. ++*ip;
  3. (*ip)++;

//指针间赋值

语法: iq = ip;

/* 如果iq和ip同样是指向整型的指针,则将ip中的值copy到iq中,iq也将指向ip所指向的对象 */

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

指针传递

语法:

swap(a,b);

void swap(int *p,int *q)

特点:

  1. 调用方法传参,仅改变指针p的地址 &p ;
  2. *p=12赋值,仅改变内存块的值 *p ;
  3. p=&a指向变量a,仅改变内存块位置 p ;
  4. 调用方法结束,p的地址和内存块都不变,但如果在调用过程中内存块被修改,则值改变 ;

举例:

#include <stdio.h>

void pointer(int *p)

{

printf("\nthe p is %p , addr is %d, *p is %d", p , &p, *p);

,但值和指向的内存块数据没变

*p = 12;

printf("\nthe p is %p , addr is %d, *p is %d", p , &p, *p);

,内存块 00F0FF2C 的值变成了22

int a = 11;

p = &a;

printf("\nthe p is %p , addr is %d, *p is %d", p , &p, *p);

//Line 4 p1的值指向a,即p1指向a 内存块 0060FEFC,此时p1与p分别指向不同的内存块了,不会互相影响

}

int main()

{

int b = 22;

int *p = &b;

printf("\nthe p is %p , addr is %d, *p is %d", p , &p, *p);

//Line 1 *p指向b的地址:获得了p(内存块数据)&p(地址)*p(值)

pointer(p);

printf("\nthe p is %p , addr is %d, *p is %d", p , &p, *p);

}

输出:

其他传递方式(来源参考他人)

  1. 传值方式 //和函数的值传递不是一个概念

    语法:

    swap(&a , &b);

    void swap(int *a , int *b)

    // 传入的是变量a的地址 &a,函数接收到的是传入地址的值

    // 使用指针方式修改指向内存块的值,传入的是 a、b变量地址的拷贝。

    注意:函数的值传递的方式是

    swap(a , b);

    void swap(int a , int b)

  2. 传引用方式

    语法:

    swap(a,b);

    void swap(int &p,int &q)

    // 使用引用方式,传入的是变量a、b,而不是拷贝,地址不变。

举例:

#include <stdio.h>

void swap(int *a , int *b)

//方法一:传值方式

{

printf("\n\n /*** Method 1 ***/");

printf("\n &a addr : %d , &b addr: %d", &a, &b);

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

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

int temp = *a;

*a = *b;

*b = temp;

}

void swap(int &a , int &b)

//方法二:传引用方式

{

printf("\n\n /*** Method 2 ***/");

printf("\n &a addr : %d , &b addr: %d", &a , &b);

int temp = a;

a = b;

b = temp;

}

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

{

int a = 3 , b = 5;

printf(" &a addr : %d , &b addr: %d", &a , &b);

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

swap(&a , &b); //方法一

printf("\n &a addr : %d , &b addr: %d", &a, &b);

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

swap(a , b); //方法二

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

return 0;

}

输出:

————————————————————————————————————————————

数组指针和指针数组

注意:赋值符号"="号两边的数据类型必须是相同的,通过这点可以排除在写数组与指针时的错误;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

数组指针 //指向数组的指针

注意:不同的数据类型占的地址数(字节)不同,char:1,int:4,float:4,double:8

定义:

//一维

#include <stdio.h>

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

{

//int,char同理

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

int (*p)[5] = &temp;//指针p指向temp数组的首地址

int i;

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

{

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

//*p指向temp数组的首地址,*p+i代表后移几个字节的地址,*(*p+i)代表指向地址的值

}

return 0;

}

//二维,行指针

#include <stdio.h>

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

{

int array[4][5] = {{1, 2, 3, 4, 5}, {11, 12, 13, 14, 15}, {21, 22, 23, 24, 25}, {31, 32, 33, 34, 35}, {41, 42, 43, 44, 45}};

个元素的一维数组。或直接写成 int (*p)[5] = array;

p = array;//将该二维数组的首地址赋给p,也就是a[0]或&a[0][0]

//在这里,数组指针p共有三个int指针,赋值时意味着将p的三个指针指向 array第一行的三个元素;

for (int i = 0; i < 4; ++i)

{

for (int j = 0; j < 5; ++j)

{

printf("%2d ", *(*(p + i) + j));

}

printf("\n");

}

return 0;

}

另一种表达方式:

...

int (*p)[4][5]=&array;

...

printf("%2d ", *(*(*p + i) + j));

...

//都表示数组中i行j列一个元素

*(p+i) == p[i]

*(*(p+i)+j) == p[i][j] == *(p[i]+j) == (*(p+i))[j]

*(*(*(p+i)+j)) == p[i][j][k]

p++;//该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][]

大小:在32位系统下永远是4字节

例1:

#include <stdio.h>

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

{

int a[10];

int *p, i;

for (i = 0; i < 10; ++i)

{

scanf("%d", &a[i]);

}

for (p = &a[0]; p < (a + 10); p++)

//p+i = a+i = &a[i] 这三者意思相同,所以循环结构使用 p < (a + 10),等价于 i < 10

{

printf("%d ", *p);

}

return 0;

}

例2:

#include <stdio.h>

int main()

{

//数组指针的大小必须与数组相同,否则编译不通过,此处均为[5]

char a[5] = {'a', 'b', 'c', 'd'};

//p1 和p2 都是数组指针,指向的是整个数组

//&a 是整个数组的首地址,a是数组首元素的首地址

char (*p1)[5] = &a;

//p1指向&a是对的,左右都是整个数组的首地址

char (*p2)[5] = a;

//p2指向a,编译时会出现warming,但是"="两边的数据类型不一致,左边的是指向整个数组的指针,右边的数据类型是指向单个字符的指针。

char (*p3)[5] = (char (*)[5])a;

//p2类型如果要正常使用的话则使用p3这种强制转换,右边强制转换成为a整个数组的首地址

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

printf("a=%c\n", a[0]);

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

printf("p1=%c\n", **p1);

printf("p2=%c\n", **p2);

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

printf("p1+1=%c\n", **(p1 + 1));

printf("p2+1=%c\n", **(p2 + 1));

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

return 0;

}

输出:

出现的warming信息为p2导致,左右类型不一致

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

指针数组 //用于存储指针的数组

定义:

//一维

#include <stdio.h>

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

{

//int

int a = 1;

int b = 2;

int c = 3;

int d = 4;

int e = 5;

int *p[5] = {&a, &b, &c, &d, &e};//数组里面每一个元素都指向abcde的地址

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

{

printf("%d ", *p[i]);//循环打印每一个指针对应地址的值 *

}

//char

char *q[5] = {"aaa", "bbb", "ccc", "ddd", "eee"};

for (int j = 0; j < 5; ++j)

{

printf("%c ", *q[j]); //加*表示取出的是字符

}

for (int k = 0; k < 5; ++k)

{

printf("\n%s", q[k]);//不加*表示字符串

}

return 0;

}

//二维

int *p[3]; //定义的p数组中的三个元素都是int指针,分别是p[0]、p[1]、p[2],所以要分别赋值。

int a[3][4];

p++; //该语句表示p数组指向下一个数组元素。注:此数组每一个元素都是一个指针

for(i=0;i<3;i++)

p[i]=a[i];

//都表示数组中i行j列一个元素

*(p+i) == p[i]

*(*(p+i)+j) == p[i][j] == *(p[i]+j) == (*(p+i))[j]

*(*(*(p+i)+j)) == p[i][j][k]

赋值:*p=a; //这里*p表示指针数组第一个元素的值,a的首地址的值。

大小:数组的大小由数组本身来决定,32位系统下每个指针占4字节,大小不确定;

举例:

#include <stdio.h>

int main()

{

int i;

char c1[] = "How";

char c2[] = "are";

char *c3 = "you"; //该指针变量指向字符串所在字符数组的首地址。

char *pArray[3]; //该数组元素可以指向char类型或数组类型

pArray[0] = c1; //指针变量pArray[0]指向了c1的首地址

pArray[1] = c2;

pArray[2] = c3;

for(i = 0; i < 3; i++)

printf("%s ", pArray[i]); //printf("%s ", pArray[0])等价于printf("%s ", c1)

return 0;

}

输出:

出处: http://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html

出处: http://www.cnblogs.com/mq0036/p/3382732.html

————————————————————————————————————————————

结构体

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

编译器会将结构体的数据进行内存对其,如果定义 char a;int b;char c;

对其前:6个字节

a

b

b

b

b

c

对其后:12个字节

a

b

b

b

b

c

如果定义的是 char a;char c;int b;

则调整为

a

c

b

b

b

b

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

定义

#include <stdio.h>

//第一种定义方法

struct Book //定义结构体名

{

char title[128];

char author[40];

float price;

unsigned int date;//无符号整型

char publisher[40];

} book;//book是结构体变量名

//第二种定义方法

struct Book2

{

float price2;

unsigned int date2;

} book2;

//第三种定义方法

struct Book3

{

int number;

int number2;

} book3 = {1, 2};

//结构体嵌套

struct Data

{

int year;

int month;

int day;

};

struct Nested

{

struct Data data;

char a;

} nested =

{

{2017, 4, 17},

'i'

};

int main(void)

{

//第一种初始化方法

struct Book book =//初始化结构体

{

"aaa",

"bbb",

12.0,

20170417,

"ccc"

};

//第二种初始化方法

struct Book2 book2 =//通过这种写法只初始化某一个变量

{

.price2 = 48.0

};

//scanf("%s",book.title);

//scanf("%s",book.author);

//...

printf("%s\n", book.title);

printf("%s\n", book.author);

printf("%f\n", book.price);

printf("%d\n", book.date);

printf("%s\n", book.publisher);

printf("- - - - - - - - \n");

printf("%f\n", book2.price2);

//...

printf("- - - - - - - - \n");

//结构体嵌套打印

printf("%d %d %d\n", nested.data.year, nested.data.month, nested.data.day);

return 0;

}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

结构体数组

#include <stdio.h>

//第一种定义方法

struct Way1

{

char a;

char b;

int c;

} way1 [3];

//第二种定义方法

struct Way2

{

char d;

char e;

int f;

};

struct Way2 way2 [10];

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

{

//初始化结构体数组

struct Way1 way1[3] =

{

{'a', 'b', 0},

{'c', 'd', 1},

{'e', 'f', 2}

}

return 0;

}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

结构体指针

#include <stdio.h>

struct Book

{

char title[128];

char author[40];

float price;

unsigned int date;

char publisher[40];

} book =

{

"aaa",

"bbb",

12.0,

20170417,

"ccc"

};

int main(void)

{

struct Book *pt;

pt = & book;//结构体的变量名并不是指向结构体的地址,定义结构体指针时必须使用 &

//第一种方法

printf("%s\n", (*pt).title);

printf("%s\n", (*pt).author);

printf("%f\n", (*pt).price);

printf("%d\n", (*pt).date);

printf("%s\n", (*pt).publisher);

printf("- - - - - - - - - - -\n");

//第二种方法

printf("%s\n", pt->title);

printf("%s\n", pt->author);

printf("%f\n", pt->price);

printf("%d\n", pt->date);

printf("%s\n", pt->publisher);

return 0;

}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

传递结构体变量

#include <stdio.h>

struct Date

{

int year;

int month;

int day;

};

struct Book

{

char title[128];

float price;

struct Date date;

};

struct Book getInput(struct Book book);

struct Book getInput(struct Book book)

{

printf("input the title:");

scanf("%s", book.title);

printf("input the price:");

scanf("%f", &book.price);

printf("input the date:");

scanf("%d %d %d", &book.date.year, &book.date.month, &book.date.day);

return book;

}

struct Book printBook(struct Book book);

struct Book printBook(struct Book book)

{

printf("%s\n", book.title);

printf("%f\n", book.price);

printf("%d-%d-%d", book.date.year, book.date.month, book.date.day);

}

int main()

{

struct Book b1, b2;

printf("input the first info\n");

b1 = getInput(b1);

printBook(b1);

return 0;

}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

传递指向结构体变量的指针 //基本结构同上

#include <stdio.h>

struct Date

{

int year;

int month;

int day;

};

struct Book

{

char title[128];

float price;

struct Date date;

};

void getInput(struct Book *book);

void getInput(struct Book *book)//不需要返回值,直接定义成为void即可

{

printf("input the title:");

scanf("%s", book->title);

printf("input the price:");

scanf("%f", &book->price);

printf("input the date:");

scanf("%d %d %d", &book->date.year, &book->date.month, &book->date.day);

}

void printBook(struct Book *book);

void printBook(struct Book *book)

{

printf("%s\n", book->title);

printf("%f\n", book->price);

printf("%d-%d-%d", book->date.year, book->date.month, book->date.day);

//void类型没有返回值 return

}

int main(void)

{

struct Book b1, b2;

printf("input the first info\n");

getInput(&b1);//调用时直接取地址

printBook(&b1);

return 0;

}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

动态申请结构体

//使用malloc函数为结构体分配存储空间,free函数释放

#include <stdio.h>

#include <stdlib.h>

struct Date

{

int year;

int month;

int day;

};

struct Book

{

char title[128];

float price;

struct Date date;

};

void getInput(struct Book *book);

void getInput(struct Book *book)//不需要返回值,直接定义成为void即可

{

printf("input the title:");

scanf("%s", book->title);

printf("input the price:");

scanf("%f", &book->price);

printf("input the date:");

scanf("%d %d %d", &book->date.year, &book->date.month, &book->date.day);

}

void printBook(struct Book *book);

void printBook(struct Book *book)

{

printf("%s\n", book->title);

printf("%f\n", book->price);

printf("%d-%d-%d", book->date.year, book->date.month, book->date.day);

}

int main(void)

{

struct Book *b1, *b2;

b1 = (struct Book *)malloc(sizeof(struct Book));

if (b1 == NULL)

{

printf("内存分配失败\n");

exit(1);

}

printf("input the first info\n");

getInput(b1);//因为b1是指针,所以不需要取地址操作符

printBook(b1);

free(b1);

return 0;

}

————————————————————————————————————————————

预处理器

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

文件包含 #include "文件名" 或 #include <文件名>

  1. 用" "引起来,则在源文件所在的位置查找该文件;
  2. 如果在该位置没有找到文件或用< >括起来的,则根据相应的规则查找该文件,这个规则同具体的实现有关

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

两个预处理语句 #ifdef 和 #ifndef

用法:

#ifndef HDR

#define HDR

/* hdr.h文件的内容在这里*/

#endif

/* 用来测试某个名字是否已经定义,等价于 */

#if !defined(HDR)

#define HDR

#endif

举例:

/* 测试SYSTEM变量后确定包含某个文件 */

#if SYSTEM == SYSV

#define HDR "sysv.h"

#elif SYSTEM == BSD

#define HDR "bsd.h"

#elif SYSTEM == MSDOS

#define HDR "msdos.h"

#else

#define HDR "default.h"

#endif

#include HDR

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

宏替换

  1. #define 名字替换文本

    用法:较长的替换文本可以在待续的行末尾加上反斜杠符 \

    举例:

    1. 例:#define forever for(;;)

      /* 该句为无限循环定义了一个新名字forever */

    2. 例:#define max(A,B) ((A)>(B)?(A):(B))

      /* 形参A和B每次出现都将被替换成对应的实际参数,不过要适当使用括号来规范计算次序的正确性 */

    3. 例:#define dprint(expr) printf(#expr " = %g\n",expr)

      /* 当使用时dprintf(x/y);时被扩展为 printf("x/y" "= %g\n",x/y); */

    4. 例:#define paste(front,back) front ## back

      /*预处理器运算符## 为宏定义提供了连接实际参数的手段*/

      /* 在调用paste(name,1)时,将建立记好 name1*/

  2. #undef getchar

    int getchar(void){...}

    用法:通过#undef 取消名字的宏定义,这样可以保证后续的调用是函数调用,而不是宏调用

————————————————————————————————————————————

getchar /putchar 输入输出

语法:

c = getchar(); // 获取控制台输入

putchar(c); //输出

————————————————————————————————————————————

EOF,End Of File,文件尾标志。 从数值上来看,就是整数-1

linux:在输入回车换行后的空行位置,按 ctrl+d (先按ctrl键,不放,再按d键)

windows:在输入回车换行后的空行位置,按 ctrl+z,再回车确认

————————————————————————————————————————————

C语言 | 基础知识点笔记的更多相关文章

  1. JavaScript语言基础知识点图示(转)

    一位牛人归纳的JavaScript 语言基础知识点图示. 1.JavaScript 数据类型 2.JavaScript 变量 3.Javascript 运算符 4.JavaScript 数组 5.Ja ...

  2. JavaScript 语言基础知识点总结

    网上找到的一份JavaScript 语言基础知识点总结,还不错,挺全面的. (来自:http://t.cn/zjbXMmi @刘巍峰 分享 )  

  3. JavaScript语言基础知识点图示

    原文:JavaScript语言基础知识点图示 一位牛人归纳的JavaScript 语言基础知识点图示. 1.JavaScript 数据类型 2.JavaScript 变量 3.Javascript 运 ...

  4. Go语言--基础语法笔记

    ### 换了工作,好久没有添加新文章了,本来是想更新到github上的,想想还是在博客里放着,感觉以前的文章都没有很仔细,都只是问题处理的记录, 以后想新加一些整理的笔记也好 ### 主要内容 2.1 ...

  5. object - c 语言基础 进阶笔记 随笔笔记

    重点知识Engadget(瘾科技)StackOverFlow(栈溢出)Code4Apprespon魏先宇的程序人生第一周快捷键: Alt+上方向键 跳到最上面  Alt+下方向键 跳到最下面      ...

  6. 从零开始系列-R语言基础学习笔记之二 数据结构(二)

    在上一篇中我们一起学习了R语言的数据结构第一部分:向量.数组和矩阵,这次我们开始学习R语言的数据结构第二部分:数据框.因子和列表. 一.数据框 类似于二维数组,但不同的列可以有不同的数据类型(每一列内 ...

  7. 从零开始系列--R语言基础学习笔记之一 环境搭建

    R是免费开源的软件,具有强大的数据处理和绘图等功能.下面是R开发环境的搭建过程. 一.点击网址 https://www.r-project.org/ ,进入"The R Project fo ...

  8. JavaScript 语言基础知识点总结(思维导图)

    JavaScript 数组 JavaScript 函数基础 Javascript 运算符 JavaScript 流程控制 JavaScript 正则表达式 JavaScript 字符串函数 JavaS ...

  9. python语言基础语法笔记<note2--面向对象编程>

    Python面向对象编程(OOP) 一.面向对象过程的优点特征: 封装 模型的特征和能力打包在一起 模型的改变由模型自身完成 隐藏模型的细节,外界只能使用,不能改变 继承 符合自然界分类规律 快速实现 ...

随机推荐

  1. linux中高端内存和低端内存的概念【转】

    转自:http://blog.csdn.net/hdujinhuihui/article/details/8686817 高端内存是Linux中一个重要的概念,初涉Linux时曾经对这个概念非常迷惑. ...

  2. 【linux高级程序设计】(第九章)进程间通信-管道 1

    Linux操作系统所支持的主要进程间的通信机制. 无名管道 PIPE cat test.txt| grep hello 上面这种管道,将一个命令的输出作为另一个命令的输入,而这种管道是临时的,命令执行 ...

  3. hdu 5125(LIS变形)

    题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=5125 题解: 这个题dp[i][0],dp[i][1]数组分别记录在第i个位置取a[i]和b[i]时 ...

  4. hdu 5062(水题)

    Beautiful Palindrome Number Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 32768/32768 K (J ...

  5. spring boot的pom.xml配置,正确生成jar包

    spring boot生成的jar包提示没有主清单属性. 需要在pom里加入配置. <?xml version="1.0" encoding="UTF-8" ...

  6. Codeforces 935E Fafa and Ancient Mathematics(表达式转树 + 树型DP)

    题目链接  Codeforces Round #465 (Div. 2) Problem E 题意  给定一个表达式,然后用$P$个加号和$M$个减号填充所有的问号(保证问号个数等于$P + M$) ...

  7. 警告Conversion specifies type'int' but the argument has type'size_t'

    代码: #import<Foundation/Foundation.h> int main(int argc,const char * argv[]){ const char *words ...

  8. SQL Reverse函数

    原文:SQL Reverse函数 Sql sever里面有个自带的reverse函数,这个函数的主要功能是把一个字符产反转.比如对于: select REVERSE('hello,world') 将得 ...

  9. UBIFS分区制作及UBIFS烧写和启动

    参考 http://blog.csdn.net/chongzi865458/article/details/6799258 ubiattach version 1.0 - a tool to atta ...

  10. UBIFS

    转:http://www.armadeus.com/wiki/index.php?title=UBIFS This is a preliminary page dealing with the ins ...