（转）linux c语言

原

Linux C语言结构体-学习笔记

2018年07月22日 13:02:31 天涯明月笙 阅读数 633 更多

分类专栏： C语言学习攻略

Linux C语言结构体简介

前面学习了c语言的基本语法特性，本节进行更深入的学习。

• 预处理程序。 编译指令: 预处理, 宏定义，
• 建立自己的数据类型：结构体，联合体，动态数据结构
• c语言表达式工具 逻辑运算符： & | ^ ~ << >>
• 函数的递归调用方法

什么是预处理

vim helloworld.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

helloworld.c：

#include 

int main()
{
    printf("hello,world!\n");
    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
   
   
   
   

编译的目的:

从c语言.c源文件变成可执行文件

gcc helloworld.c -o helloworld.out
./helloworld.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

编译的四个步骤:

.c文件->.i文件->.s文件->.o文件->可执行文件(可运行)

• 1. 预处理
• 1. 编译
• 1. 汇编
• 1. 链接

记忆法: ISO三步走战略。

下面我们来查看预处理中要做的事情:

gcc -o helloworld.i helloworld.c -E
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

-E表示只让gcc执行预处理。

// 查看helloworld.i文件
cat helloworld.i
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

vim跳到整个文档底部，命令: :$

可以看到代码的底端是我们的main函数

对比一下.i文件和.c文件的区别

首先:它们都是c的语法。其次.c文件main函数上面是#include

而.i 文件中这行代码不见了，变成了上面这些东西。

所以预处理所做的第一件事情就是展开头文件

将#include 中stdio.h展开,将未注释的内容直接写入.i文件。

在预处理步骤中，除了展开头文件，还要进行宏替换。

宏是什么

c语言常量分为直接常量和符号常量:

#define 标识符 常量值 (注意:没有分号)
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

helloMacro.c源代码：

#include 
#define R 10

int main()
{
    int a =R;
    printf("a=%d\n");
    printf("hello,world!\n");
    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
   
   
   
   

gcc -o helloMacro.i helloMacro.c -E
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

预处理过之后的代码

# 4 "helloworld.c"
int main()
{
    int a =10;
    printf("a=%d\n");
    printf("hello,world!\n");
    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

可以看到10是直接当做一个字符串来替换原本的宏定义R。

宏的本质是发生在预处理阶段单纯的字符串替换(宏替换), 在预处理阶段,宏不考虑语法;

示例代码2:
vim helloMacro2.c

#include 
#define R 10
#define M int main(

M){
    printf("hello,world!\n");
    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

gcc helloMacro2.c -o helloMacro2.out
./helloMacro2.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

预处理是没有问题的,可以成功的编译执行。宏不考虑C语言的语法。它很单纯，字符串替换。

• 宏用于大量反复使用的常量、数组buffer的大小，为了便于修改定义成宏。

通常定义数组我们这样写:

int a[10];
int b[10];
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

定义两个相同大小的数组，这里我们就可以改为下面代码。

#define R 10
int a[R];
int b[R];
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

一次修改，可以修改两份。

宏也是可以传递参数的，可以做一些函数可以做的事情

宏函数

vim helloMacroFunction.c
源代码：

#include 
#define R 10
#define M int main(
#define N(n) n*10



M){
    int a = R;
    int b = N(a);
    printf("b = %d\n",b);
    printf("a =%d\n",a);
    printf("hello,world!\n");
    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
   
   
   
   

gcc helloMacroFunction.c -o helloMacroFunction.out
./helloMacroFunction.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

这里的处理过程: 首先将参数a替换到上面的宏中，上面就变成了N(a) a*10,之后再用a*10替换下面的N(a)

int b = N(a); //变成了 int b =a*10;
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

gcc -o helloMacroFunction.i helloMacroFunction.c -E
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

预处理之后：

# 8 "hello.c"
int main(){
    int a = 10;
    int b =a*10;
    printf("b = %d\n",b);
    printf("a =%d\n",a);
    printf("hello,world!\n");
    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
   
   
   
   

先不考虑宏实现，先来写一个正常的求和函数。

vim helloAdd.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
#define R 20
#define M int main(
#define N(n) n*10

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


M){
    int a = R;
    printf("a =%d\n",a);
    printf("hello,world!\n");

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

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

    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
   
   
   
   

gcc helloAdd.c -o helloAdd.out
./helloAdd.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

使用宏函数实现求和。

vim helloAddMacro.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
#define R 20
#define M int main(
#define N(n) n*10
#define ADD(a,b) a+b
int add(int a,int b){
    return a+b;
}


M){
    int a = R;
    printf("a =%d\n",a);
    printf("hello,world!\n");

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

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

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

    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
   
   
   
   

gcc helloAddMacro.c -o helloAddMacro.out
./helloAddMacro.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

可以看到使用宏函数和普通函数的求和效果是一致的。结果与简单的字符串替换一致。

ADD(a,b) 被替换成 a+b 因此式子变成int d = a+b;

gcc -o helloAddMacro.i helloAddMacro.c -E
vim helloAddMacro.i
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

版本3，宏定义中优先级问题。

#include 
#define R 20
#define M int main(
#define N(n) n*10
#define ADD(a,b) a+b
int add(int a,int b){
    return a+b;
}


M){
    int a = R;
    printf("a =%d\n",a);
    printf("hello,world!\n");

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

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

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

    int e =ADD(a,b) * ADD(a,b);
    printf("e =%d\n",e);

    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
   
   
   
   

预测一下e的输出为: a+b*a+b ab先乘起来，a=20，b=200，ab=4000，然后加上a，b：得到结果(4220)

gcc helloAddMacroPrecedence.c -o helloAddMacroPrecedence.out
./helloAddMacroPrecedence.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

运算是等我们编译完了，执行的时候才会运行的。预处理阶段不会进行运算操作。

• 宏定义时由于本质是字符串的替换

真正运算的时候，会按照运算符号的优先级来进行

解决方案:

#define ADD(a,b) (a+b)
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

gcc helloAddMacroPrecedence.c -o helloAddMacroPrecedence2.out
./helloAddMacroPrecedence2.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

加个括号，保证优先级更高一点。

宏函数和正常函数的优势？

正常的add函数需要返回值类型，需要传递进来的参数有类型要求。

讲传入的a,b 类型进行改变，如变为两个浮点型数，程序就会自动类型转换。

但是宏函数就没有这种要求可以不用考虑输入值的类型，这与普通的函数定义不同。

int c =add(10.5,20.4);
printf("c =%d\n",c);

float d =ADD(10.5,20.4);
printf("d =%f\n",d);
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

gcc helloAddMacroPrecedenceCompare.c -o helloAddMacroPrecedenceCompare.out
./helloAddMacroPrecedenceCompare.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

普通函数例如int add(int a,int b)除了在开头要声明值的类型，还要设置返回值，因此在定义过程与调用过程相对复杂。若能用宏定义实现的情况应优先考虑宏定义.

宏是不考虑数据类型，不考虑c语言的语法的。只是简单的字符串的处理。

预处理阶段，除了宏之外，还提供了一个叫做mtianyan:条件编译的功能。

可以按照不同的条件，编译不同的程序部分，从而产生不同的目标代码文件。对于程序的移植和调试都是很有用的。

下集预告: 和宏比较相近的功能，typedef

Linux C预处理之typedef

严格来讲，typedef和预处理是没多大关系的，放在这里是因为容易搞混淆。

• typedef作用是给一个变量类型起别名。

简记: 取别名; 但是属于C语法, 结束要加分号, 与#define不同, 它不需要加分号。

typedef int tni;
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

将int用tni代替,在之后的int定义可直接写为:

tni a;
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

我们之前定义指针的情况:

int *p;
// 如果我们加上typedef
typedef int *p;
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

typedef int *p; 是给int * 这个数据类型(还记得大明湖畔我们说过的，typedef作用是给一个变量类型起别名)起了别名p

pq=null
// 根据上面的typedef等价于
int* q=null
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

将int类型换成tni:

typedef int tni;

M){
    tni a = R;
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

gcc helloAddMacroPrecedenceCompareTypedef.c -o helloAddMacroPrecedenceCompareTypedef.out
./helloAddMacroPrecedenceCompareTypedef.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

可以看到程序可以成功的运行，注意，真名可以和别名共存。

之前我们已经试验过了宏是会在预处理阶段被替换的,而tni不会在.i文件中被替换。

gcc -o helloAddMacroPrecedenceCompareTypedef.i helloAddMacroPrecedenceCompareTypedef.c -E
vim helloAddMacroPrecedenceCompareTypedef.i
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

我们通常在使用typedef的时候,通常都是给自己自定义的数据类型起别名。

比如size_t就是系统给我们定义的一个类型的别名。

typedef unsigned long size_t;

// 定义一个结构体
struct stu{
};

// 使用结构体的时候
struct stu xxx;

// 给结构体起别名
typedef struct stu{
} stu_t;
// 起了别名之后使用结构体
stu_t xxx;
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
   
   
   
   

区别2: 宏定义开头声明，全局任何作用域都可以直接使用。

注意typedef如果写在方法体内,则只可作用于该作用域的花括号内。

下节课: 结构体

结构体的声明与定义

之前的学习中，使用的变量类型大多是一些比较简单的变量类型。

比如:

int a = 0;
float b =0.0;
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

这些变量之间没有什么联系,然而很多时候我们存储的数据比较复杂，不能通过简单的类型进行描述。

比如我们需要存储一个武器的信息:

它会包含武器的很多信息。之前的所有数据类型，都不足以描述一个武器的多种信息。

数组也不行，因为数组只能存放同类型的数据，武器的名字和价格类型不同。

结构体是不同类型变量的集合 & 数组是相同类型变量的集合

vim Cstructweapon.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
struct weapon{
    // 武器名字
    char name[20];
    // 攻击力
    int atk;
    // 价格
    int price;
};

int main()
{
   int a =0;
   float b =0.0;

   struct weapon weapon_1;
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
   
   
   
   

struct 结构体类型名{}，只是创建了一个结构体类型。

但是我们可以使用这一结构体类型struct weapon来声明变量

struct weapon weapon_1;
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

这种定义方法是声明和定义分离的形式。

第二种直接在声明时去定义。

struct weapon{
    // 武器名字
    char name[20];
    // 攻击力
    int atk;
    // 价格
    int price;
}weapon_1;
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

相当于定义了一个全局变量，变量名为weapon_1，类型是struct weapon。简单程序可以运用

第三种方法:

struct{
    // 武器名字
    char name[20];
    // 攻击力
    int atk;
    // 价格
    int price;
}weapon_1;
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

这种方法就不能用这个结构体类型去定义其他的变量。匿名结构体类型。

下节课预告: 如何进行结构体的初始化与引用

结构体的初始化与引用。

定义了结构体之后: 我们要知道如何初始化，以及如何访问结构体成员

在对结构体进行初始化的时候，可以等于一个初始化列表。通过一个花括号将常量括起来，
依次赋值给结构体成员。

struct weapon weapon_1 = {"weapon_name",100,200};
// 访问结构体里的成员，使用点
printf("%s\n,%d\n",weapon_1.name,++weapon_1.price);
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

#include 
struct weapon{
    // 武器名字
    char name[20];
    // 攻击力
    int atk;
    // 价格
    int price;
};

int main()
{
   int a =0;
   float b =0.0;

   struct weapon weapon_1 = {"weapon_name",100,200};
   // 访问结构体里的成员，使用点
   printf("%s\n%d\n",weapon_1.name,++weapon_1.price);
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
   
   
   
   

gcc Cstructweapon.c -o Cstructweapon.out
./Cstructweapon.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

结构体成员变量可以和普通变量一样进行操作。weapon_1.name应该被我们视为一个整体

a++;
++weapon_1.price //可以看出它可以像普通变量一样操作
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

结构体数组

如果我们需要十个武器的数据，我们需要使用数组，结构体数组。

• .(点)运算符是一个成员运算符，在所有运算符中运算级最高，可用.运算符访问结构体内部成员.

结构体数组和普通数组，差别不大。

int a[2]; // 包含两个int类型的元素

//结构体数组里包含两个结构体类型的元素，每个元素有结构体里的三个成员
struct weapon weapon_2[2]; // 每个元素都是一个结构体类型的数据
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

vim CstructweaponArray.c(在原基础上添加代码)

struct weapon weapon_2[2]={{"weapon_name1",50,100},{"weapon_name2",99,200}};
printf("%s\n%d\n",weapon_2[0].name,weapon_2[1].atk);
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

gcc CstructweaponArray.c -o CstructweaponArray.out
./CstructweaponArray.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

两种结构体数组的初始化方式:

// 直观式
struct weapon weapon_2[2]={{"weapon_name1",50,100},{"weapon_name2",99,200}};
// 一般式
struct weapon weapon_2[2]={"weapon_name1",50,100,"weapon_name2",99,200};
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

两种方式都可以成功的初始化。

结构体指针

了解: 什么是指向结构体变量的指针变量，以及如何去使用这个变量。

struct weapon *w ;  //定义一个指向weapon的w结构体指针
w=&weapon_1;       //具体指向weapon_1的内存地址

(*w).name           //左右两侧的括号不可省略，因为.运算符优先级高于星
w->name          // 箭头叫做指向运算符
weapon_1.name   //这3种访问类型都是一样效果
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
   
   
   
   

vim CstructweaponArrayPointer.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

struct weapon * w;
w = &weapon_1;
printf("---------------------------------\n");
printf("name=%s\nname=%s\nname=%s\n",(*w).name,w->name,weapon_1.name);
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

gcc CstructweaponArrayPointer.c -o CstructweaponArrayPointer.out
./CstructweaponArrayPointer.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

结构体数组指针

cp CstructweaponArrayPointer.c CstructweaponArrayPointer2.c
vim CstructweaponArrayPointer2.c
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

结构体数组指针,不用取地址符&

数组的名字代表了这个数组的内存首地址, 数组括号内的长度代表了数组的单元数,数据类型是int的话就按照int类型(32位系统上是4个字节)乘以单元数的长度，如果数据类型是结构体的话就按照结构体的长度乘以单元的长度。

p++，不是内存位置右移了一个字节，而是右移了一个单位长度的结构体weapon的内存长度。所以就不难理解为什么右移到了第二个结构体实例的首地址上了。

struct weapon weapon_2[2]={{"weapon_name1",50,100},{"weapon_name2",99,200}};
struct weapon *p;
p = weapon_2; //数组的名字对应着数组第一个元素的起始地址

// 取成员值: p->name 相当于 weapon_2[0].name
printf("%s\n",p->name);
printf("---------------------------------\n");
p++; // 等价于 weapon_2+1 让其指向weapon_2[1]
printf("%s\n",p->name);
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
   
   
   
   

gcc CstructweaponArrayPointer2.c -o CstructweaponArrayPointer2.out
./CstructweaponArrayPointer2.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

Linux C 公用体

公用体类型也被称之为联合体，创建公用体类型可以使用关键字union

理解起来很简单，让几个不同类型的变量共享同一块内存地址

vim union.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
union data{
    int a;
    char b;
    int c;
}; // 代表a,b,c会只在同一个内存空间。

int main()
{
   union data data_1;
   data_1.b ='C';
   data_1.a =10; // 后面被赋值的成员才是真正起作用的成员
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
   
   
   
   

优点是节省一部分的开销。缺点: 同一时刻只能存储一个成员。

比如，对b进行赋值，对a进行赋值。以最后一个赋值为准，因为所有成员共享一块内存。
(后赋值的会把前面的覆盖掉)

共用体类型的长度是所有成员中最长的那个成员的长度。比如上面的例子中int有四个字节，char只有一个字节。int就是最长的，因此这个共用体类型就占四个字节。

union data data_1 = {10};
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

因此在对公用体或联合体赋值的时候，只能给一个变量。

对于结构体来说，这个是不一样的

struct data{
    int a;
    char b;
    int c;
};
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

可能会下意识的以为struct占用的内存空间大小是这几个成员变量的大小之和。 4+1+4=9

结构体的内存大小占用，涉及字节对齐，是一种计算机用空间换取时间的方式。

大小 = 最后一个成员的偏移量+最后一个成员的大小+(可选)末尾填充字节数。
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

偏移量就是某一个成员的实际地址和结构体首地址之间的距离。(偏移量，实际地址和结构体首地址之间的距离)

• 对于成员a来说，a的地址就是结构体的首地址，偏移量0;
• b的偏移量4，自身大小为1;
• 结构体字节对齐准则: 每个结构体相对于首地址的偏移量都得是当前成员所占内存大小的整数倍，否则就会加上填充字节。
• c的偏移量为5，c自身大小为4.因为5不是4的整数倍，字节对齐时要补齐为8.然后加上c自身的4。
  所以整个占用12。
• 然后再判断这个大小12是不是结构体中最宽的基本类型成员的整数倍。

例子中最宽的是int，4可以被12整除。 如果不能，c之后也要填充末尾填充字节数。

union共用体是多种不同数据类型的合集，所占字节按照共用体里面所占内存空间最大的类型决定。

例如有char(1字节)型和int(四字节)型，按照int型来计，整个共用体所占四个字节;
此外,共同体里面所有数据的地址是相同的,这个决定了它在有多种数据类型的时候,有且只能存放这些数据类型里面的一种数据。以最后一次赋值为准。

struct结构体也是不同数据类型的合集，所占字节按照里面所有数据类型的长度来决定.

例如：char(1字节)和int(4字节),struct所占空间是8个字节,不是5个字节,原因是涉及到字节对齐,字节对齐是为了方便计算机快速的读取数据。

vim struct_size.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
struct data{
    int a;
    char b;
    int c;
};
int main(){
   // union data data_1;
   //data_1.b ='C';
   // data_1.a =10;
   printf("%lu\n",sizeof(struct data));

   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
   
   
   
   

gcc struct_size.c -o struct_size.out
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

这里的12是这样计算来的，a是第一个成员，偏移量为0.b偏移量为4，b自身大小为1，可以整除，不用补字节，c偏移量为5，自身大小为4，字节对齐为8，加上自身大小4，12了。

然后判断12是不是结构体中最宽的基本类型成员的整数倍。

• %p表示输出这个指针
• %d表示后面的输出类型为有符号的10进制整形，
• %u表示无符号10进制整型，
• %lu表示输出无符号长整型整数(long unsigned)

vim union_address.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
union data{
    int a;
    char b;
    int c;
}; // 代表a,b,c会只在同一个内存空间。

int main()
{
    union data data_1;
    data_1.b ='C';
    data_1.a =10;
    printf("%p\n%p\n%p\n",&data_1.a,&data_1.b,&data_1.c);
    return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
   
   
   
   

gcc union_address.c -o union_address.out
./union_address.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

共用体中成员变量的地址全部相同。

Linux C 动态数据结构-静态链表

(之前使用到的都是)静态数据结构：

• 如：整型、浮点型、数组。
• 特点: 系统分配固定大小的存储空间

之后程序运行的时候，空间的位置和容量都不会再改变了。

比如我们在使用数组的时候，数组的长度就必须事先定义好。但是很多时候我们不知道。

需要一个可以动态存储分配的数据结构。也就是可变大小的数据结构。

链表：

• 有一个头指针变量head，存放地址，地址指向第一个元素。没有头指针链表无法访问
• 链表中的每一个元素都是一个节点。
• 每个节点里包含两部分，包括用户需要的数据和下一个节点的地址，各个元素的地址不一定是连续的(与数组的区别)

指向为空时链表结束。 在链表里访问某一个元素，必须通过上一个元素提供的下一个元素的地址才行。

想访问B元素，得找到a元素中存放的b元素的地址才能访问到b元素。

静态链表：

(所有节点都是在程序中定义的，而不是临时开辟的）

【由三个武器信息的节点组成，所以用结构体类型作为节点元素】

vim struct_weapon_link.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 

struct weapon{
    int price;
    int atk; // 节点的数据部分

    struct weapon * next; // 下一节点的地址
};

int main()
{
   struct weapon a,b,c,*head; // 除过三个武器，还要定义一个头指针
   a.price =100;
   a.atk = 100;
   b.price =200;
   b.atk =200;
   c.price =300;
   c.atk =300;

   // 连接成链表
   head = &a;
   a.next =&b;
   b.next =&c;
   c.next = NULL;

   struct weapon *p;
   p =head;
   while(p!=NULL){
     printf("%d,%d\n",p->atk,p->price);
     p=p->next;
   }
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
    
    
    
    
30
    
    
    
    
31
    
    
    
    
32
   
   
   
   

gcc struct_weapon_link.c -o struct_weapon_link.out
./struct_weapon_link.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

静态链表，所有的节点都是在程序中去定义的，而不是临时开辟的。

链表有一个头指针和尾指针，每个指针指向的是链表下一个数据的地址。

在结构体里面加入指针就构成链表，此时指针结构体包括两个部分，一个是信息域(数据域)，另一个是指针域。

Linux C 动态数据结构-动态链表

链表：可以用malloc来动态分配所需的内存，并且需要用free手动释放在堆里面申请的内存。

程序执行过程中从无到有的建立起一个链表，也就是说需要一个一个的开辟新节点，输入新节点的数据，然后建立起前后相连的关系。

建立武器信息的单向动态链表：

vim dynamic_linked_list.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
#include 

struct weapon{
  int price;
  int atk;
  struct weapon * next;
};

// 需要一个创建链表的函数，返回值是链表的头指针，返回类型是struct weapon *
struct weapon * create(){
   struct weapon *head;
   struct weapon *p1,*p2; // 3个指针都用来指向struct weapon类型数据,p1,p2分别指向当前新创建的节点和上一个节点。
   int n=0;// 临时变量，记录当前链表中节点个数
   // malloc分配内存块的函数，sizeof判断数据类型长度符
   // (int)malloc(16) 分配16个int型内存块
   p1=p2=(struct weapon*)malloc(sizeof(struct weapon));

   // 从键盘输入数据，给第一个节点。
   scanf("%d,%d",&p1->price,&p1->atk);
   head = NULL;// 一开始链表不存在，置空

   while(p1->price!=0){ // 约定price为0时停止输入
     n++;
     if(n==1) head=p1;
     else p2->next=p1;

     p2=p1; // 保留p1当前所指向的的地址，保留上一个节点。

     //需要开辟一个新的动态存储区，把这个的地址载给p1
     p1=(struct weapon*)malloc(sizeof(struct weapon));
     scanf("%d,%d",&p1->price,&p1->atk);//开辟后输入数据
}
p2->next=NULL;
return (head);
}//p1,p2一个用来指向链表新创立的节点，一个用来指向下一个节点
int main()
{
   struct weapon *p;
   p=create(); // p成为链表的头指针
   printf("%d,%d\n",p->price,p->atk);//打印第一个节点的信息
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
    
    
    
    
30
    
    
    
    
31
    
    
    
    
32
    
    
    
    
33
    
    
    
    
34
    
    
    
    
35
    
    
    
    
36
    
    
    
    
37
    
    
    
    
38
    
    
    
    
39
    
    
    
    
40
    
    
    
    
41
    
    
    
    
42
    
    
    
    
43
   
   
   
   

gcc dynamic_linked_list.c -o dynamic_linked_list.out
./dynamic_linked_list.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

   while(p!=NULL){
   printf("%d,%d\n",p->atk,p->price);
   p=p->next;
   }
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

C语言中的位运算符:按位与、按位或、按位异或、左移和右移

LInux C 位运算之按位与

• 位：指二进制数中的一位 0 false 1 true
• 古老的微处理器速度：比加减运算快一些，比乘除法快很多
  现在的框架中：通常与加减运算快相同，比乘除法快很多

六种位运算符

• & 按位与
• | 按位或
• ^按位异或
• ~按位取反
• <<左移
• >>右移

vim and_operation.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

• 位运算就是将参与运算的两个数据按照对应的二进制数逐位进行逻辑与运算。
• 参与运算的两个数必须是整型或者是字符型。
• 而且参与运算的数必须要以补码的方式出现。

#include 

int main()
{
   // & | ^ ~ << >>

   int a = 4; //0100 int占用4字节，32位补码。
   int b = 7; //0111

   int c = a&b; //0100 逻辑与运算

   printf("%d\n",c);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
   
   
   
   

gcc and_operation.c -o and_operation.out
./and_operation.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

按位与的应用

• 迅速清零(对于一个数中为1的位,让另一个数的相应位为0);

任何一个数和0做按位与结果一定是0

• 保留指定位置(对另一个数的相应位置1); 取a的低8位，将b的低八位全部置为一，按位与即可。
• 奇偶判断（a和1做与运算）[a&1 //得到结果1为奇数，得到0为偶数]

vim odd_even.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 

int main()
{
   // & | ^ ~ << >>

   int a =4;//0100
   int b =7;//0111

   int c =a&1;//0100

   int d =b&1;//0100

   printf("%d\n",c);
   printf("%d\n",d);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
   
   
   
   

输出为0,1; 输出为0是偶数，输出为1是奇数。

因为除过最后一位前面的都一定是2的倍数了。最后一位为1，表示是奇数。
最后一位为0，表示是偶数。

gcc odd_even.c -o odd_even.out
./odd_even.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

按位或运算。

将参与运算的两个数据按位进行逻辑或(有一个1的时候结果就是1)运算

vim bit_or.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 

int main()
{
   // & | ^ ~ << >>

   int a =9; //1001
   int b =5; //0101

   int c =a|b;//1101

   printf("%d\n",c);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
   
   
   
   

gcc bit_or.c -o bit_or.out
./bit_or.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

输出为1101(13)

按位或的作用：

设定数据的指定位,与255(0xFF)做按位或运算

比如我们想让9低八位的数据位设置为1.

a = a | 0xFF; 设定数据a的指定二进制数后8位置为1

vim bit_or_8.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 

int main()
{
   // & | ^ ~ << >>

   int a =9; //1001
   int b =5; //0101

   int c =a|b;//1101

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

   int a =a|0xff;

   printf("%d\n",a);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
   
   
   
   

gcc bit_or_8.c -o bit_or_8.out
./bit_or_8.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

按位异或^

将参与运算的两个数据按对应的二进制数逐位进行逻辑异或运算.只有对应位结果互斥，结果才为真。

vim bitwise_xor.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 

int main()
{
   // & | ^ ~ << >>

   int a =9; //1001
   int b =5; //0101

   int c =a^b;//1100

   printf("%d\n",c);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
   
   
   
   

gcc bitwise_xor.c -o bitwise_xor.out
./bitwise_xor.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

• 定位反转 让a中所有的0变成1,1变成0。

a^0xff;
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

• 数值交换

a= a^b;
b= b^a;
a= a^b;
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

vim bitwise_xor_change.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 

int main()
{
   // & | ^ ~ << >>

   int a =9; //1001
   int b =5; //0101

   a= a^b;
   b= b^a;
   a= a^b;
   printf("%d\n%d\n",a,b);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
   
   
   
   

gcc bitwise_xor_change.c -o bitwise_xor_change.out
./bitwise_xor_change.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

成功的将a,b进行了调换

涉及到的运算原理可以具体如下阐述:(下面的= 是等于的意思 而非赋值号)

P0. x^x=0
P1. a^0=a
P2. c=a^x --> a=c^x (a=a^x^x=a^0=a)
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

故有交换 解释:

a^=b; 起先 a被赋值为 a^b
b^=a; 此时 b被赋值成最开始的a值,而a保持上一步骤中的结果值不变
a^=b; 此时 a被赋值成最开始的b值,而b保持上一步骤中的结果值不变

按位取反

唯一的一个单目运算符，右结合性。把零换成1,1换成0

~1000 = 0111
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

左移：高速乘以2; 右移：高速除以2

左移：将数据对应的二进制值逐位左移若干位;

高位会被舍弃掉，低位补零; 相当于乘以2的n次方

左移需要注意的是int是一个有符号的类型，移动过程中把符号位移出去了会溢出

右移：将数据对应的二进制值逐位右移若干位

mtianyan: 低位丢弃，无符号数补零，有符号数，高位补0或1(根据符号位判断，就是正数数补0，负数补1); 相当于除以2的n次方。

vim left_right_shift.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 

int main()
{
   // & | ^ ~ << >>

   int a =3; //0000 0011
   a = a<<4; //0011 0000 32+16=48

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

   int i =1; // 0000 0001
   i = i<<33; // 相当于i<<1
   printf("i=%d\n",i);
   // 当移位位数超过该数值类型的最大位数时，编译器会用移位位数去模该类型位数，然后按照余数进行移位。 

   int b = 4;
   b = b>>1;

   printf("b=%d\n",b);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
   
   
   
   

gcc left_right_shift.c -o left_right_shift.out
./left_right_shift.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

可以看到会报出warning

递归函数之递归调用

递归调用就是在调用函数的过程中，被调用的函数调用它本身的过程。

递归调用有时候会牺牲效率

vim recursiv_call.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
void func(){
  printf("1\n");
  func();
  }

int main()
{
  func();
  return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
   
   
   
   

gcc recursiv_call.c -o recursiv_call.out
./recursiv_call.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

无尽地输出1，然后爆出段错误，核心已转储

因此我们的递归是要加上条件的。适当的时候选择是否递归，因为递归在某些时候会牺牲效率。

使用递归求阶乘

vim recursiv_call_factorial.c
   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#include 
int func(int n)
{
    int r =0;
    if(n<0){
      printf("error");
    }else if(n==0 || n==1){
    return 1;
    }else{
        r =n *func(n-1);
        return r;
    }
 }

int main()
{
   int n =0;
   printf("please input the num:");
   scanf("%d",&n);
   // 使用func求阶乘
   int result = func(n);
   printf("the result is %d\n",r);
   return 0;
}
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
   
   
   
   

gcc recursiv_call_factorial.c -o recursiv_call_factorial.out
./recursiv_call_factorial.out
   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

注意这里递归的整型溢出

递归函数之递归原理

递归是一种编程技巧，函数调用过程中函数体内又调用了它自己

函数调用的过程:

函数A调用函数B,main函数中调用A,A中调用了B,B有两个参数，a和b被称为形参。

函数没有被调用的时候，形参是不会被分配内存单元的。在A中调用了B，A就被称为主调函数。

主调函数中调用一个函数的时候，这个函数里的参数被称为实参。

函数调用所需要做的第一件事:

为被调用的函数(B)的形参分配一个临时的内存单元然后才能把两个对应的实参的值传递进来。

同时还需要传递的是主调函数(A)的返回地址。（俗称保护现场）

之所以要把A的返回地址保存起来，是因为被调函数(B)执行完了还需要继续执行主调函数(A)后面的代码。

通过return语句将函数计算后的值带回到主调函数。

保护现场时传递的返回地址，参数，函数调用结束的返回值。这些数据都保存在栈中。

递归是调用自身，但自身也是函数调用，本质就是函数的调用。

求阶乘的函数，由于递归也是符合函数调用原则的，所以所有被调用的函数都会创建一个副本，为各自的调用者服务，不受其他函数影响。递归函数被调用多少次，就会创建多少个它自身的副本。

这个副本就好像是一个新的函数一样。系统会用栈来管理它的内存。它是一个独立的存在，完全可以理解为这已经是一个新的func了。它被分配了独立的内存单元。

递归：大规模——>化简——>小规模，直到问题可求。
递归函数同时必须有 递归条件和递归表达式，否则会进入死循环。
递推(for)：则是由小问题的解逐步代入大问题并求出解。

总结

• 编译预处理：展开头文件、宏替换

• 自定义数据类型：结构体、联合体、链表实现，静态动态链表。结构体涉及字节对齐，共同体所有成员共用一个地址, 结构体内存占用计算方法。

• 逻辑运算符位运算

• 递归调用，递归思想和递推

        


	
	

			Linux C 结构体		
	

		

			03-29
			
				阅读数 
				389
			
		
	
	

		
			结构体定义：    “结构”是一种构造类型，它有若干个“成员”组成。每一个成员可以是一个基本数据类型或者是一个构造类型。结构体既然是一种“构造”而成的数据类型，那么在说明和使用之前必须先定义它，也就是...
		
		
								博文
										来自：	 景泽元的编程博客
											
	

	
	

		
			
		
	
	

		
		
		
 
			

				
			
			
			
			
			
			
发表评论
			

				
				
添加代码片
				
				
				

					
HTML/XML
					
objective-c
					
Ruby
					
PHP
					
C
					
C++
					
JavaScript
					
Python
					
Java
					
CSS
					
SQL
					
其它
				
			
  
			

				还能输入1000个字符
				
				
			
		
	


	

	
	
                  
            
              少年游 _ 64 bit：              这是什么编译器？(4个月前#1楼)举报回复

	
上一页
1
下一页

	

linux C 结构体struct的定义和初始化

02-04 阅读数 8373

struct定义：structtest{inta;longb;floatc;chard;chare[];}tt1,tt2;//对象声明列表紧跟struct定义structtesttt3,tt4;//单... 博文 来自： dragon_cdut的博客

结构体数组的初始化

03-30

#include #include typedef struct node{ char str; int len; }headtype; void Enterda 论坛

Linux C中struct的初始化允许部分初始化并且支持乱序

09-06 阅读数 379

在阅读GNU/Linux内核代码时，我们会遇到一种特殊的结构初始化方式。该方式是某些C教材（如谭二版、K&amp;amp;R二版）中没有介绍过的。这种方式称为指定初始化（designatedi... 博文 来自： jasonLee的博客

你可能感兴趣的:(C语言学习攻略)

• 剧本杀《鲸鱼马戏团》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为剧本杀《鲸鱼马戏团》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复剧本杀《鲸鱼马戏团》即可获取查看剧本杀《鲸鱼马戏团》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
• 崩坏星穹铁道哪个角色值得培养 崩坏星穹铁道新手角色优先级教学 会飞滴鱼儿
  崩坏星穹铁道新手角色培养攻略：哪些角色值得投资？在《崩坏星穹铁道》中，角色的强度和培养一直是玩家们关心的焦点。要想体验更爽快的游戏过程，选对角色至关重要。那么，哪些角色值得投资培养呢?本篇教学文章将针对新手玩家，从T0到T1强度的角色中为你做出详尽解析。游戏豹官网现在的手游平台很多，但是在游戏界有这么一个传说：“喜欢肝的玩家不如氪金玩家，氪金玩家不如内部福利玩家”，这就是游戏界可悲的生物链，很多平
• 2023-08-11 Tom梁
  当下，文玩之风可谓风靡，喜欢星月菩提的玩友越来多。有许多玩友发私信来问小编“盘玩星月菩提有没有攻略？”。所以今天给大家分享实用的星月菩提盘玩攻略，希望对大家有所帮助。一、挑选方法大家都知道挑选星月菩提的唯一标准就是密度。密度越低，上色越快；密度越高，上色就越慢。但是小编觉得高密籽更适合盘玩，虽然上色慢，但耐盘，生命周期比低密度的要长很多。那么怎么去判断它的密度呢？其实很简单，看星眼的大小、疏密、颜
• 剧本杀谁是凶手《红瞳消逝之时》凶手是谁剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为谁是凶手《红瞳消逝之时》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复谁是凶手《红瞳消逝之时》即可获取查看谁是凶手《红瞳消逝之时》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------
• 详细的等保测评攻略就在这里 快快小毛毛 网络网络安全系统安全
  信息安全等级保护，是对信息和信息载体按照重要性等级分级别进行保护的一种工作。目前我国实行的是等保2.0于2019年12月1日开始实施，等保2.0从传统的信息系统，转变成具有基础信息网络平台的多种新兴技术对象，即具有网络服务，有数据的网络服务平台都可以成为新兴的测评对象。等保2.0备案从原来的自主定级改变成系统定级，才能得到公安机关的备案，关于等保测评详细攻略如下：等保2.0定级步骤:确定定级对象—
• 《姬魔恋战纪》如何跟妹子谈场不分手的恋爱！ 专业搬砖小能手
  今天小编带你来梳理一下，国产galgame手机游戏《姬魔恋战纪》里的撩妹技巧,知己知彼才能百战百胜。刘备在主人公身边一直辅助主人公的女性，对主人公几乎有着无条件的信任。把丧失记忆的主人公当作上天派来的神使看待。对待主人公的态度非常温柔、宽容，但发现主人公偷懒后，会露出严厉的表情加以责备。兴趣是泡茶。在议事厅中泡茶给辛苦工作的主人公是她的一大乐趣之一。是一位温柔、善良的女性。攻略方式：遗迹冒险，多聊
• 破解游戏app哪个好用 无限99999钻999999金币的游戏盒子排行榜 诸葛村夫123
  2024游戏盒子网站排行榜大全随着数位科技的发展，2024年手游市场持续火爆，各种新开手游持续涌现。本文为广大手游爱好者带来巅峰推荐，总结五个最具实力的手游新服发布网站，为您提供最全面的游戏资讯以及专业的游戏攻略。▶无限99999钻999999金币的游戏盒子排行榜TOP1：游戏豹官网特点：内部特权游戏类型：多类型推荐日活跃人数：15万网址链接：www.ystt88.cn游戏介绍：游戏豹官网以快速获
• 我的神功手游氪金吗 我的神功怎么氪金最划算？ 诸葛村夫123
  《我的神功手游》新手攻略：如何在不氪金的情况下玩得过瘾？《我的神功手游》充满了江湖情怀与有趣的剧情，许多玩家可能担心游戏中氪金成为享受内容的必要条件。然而，这款游戏为广大玩家提供了许多发展途径，让您在不氪金的情况下依然能够享受完整的江湖旅程。对于大多数游戏来说，职业其实就跟氪金挂钩的，某些属于氪金玩家专属的职业是平民玩家玩不起的，这就是为什么现在的手游失去了大多乐趣的原因，而现在很多人都是选择内部
• 2022年京东618红包领取时间、玩法攻略汇总 高省APP珊珊
  2022京东618红包活动时间是什么时候开始？2022年5月30日12点至2022年6月18日23:59淘宝618密令红包公布密令：【天降红包61666】5.29日20点准时，大额红包不要错过，具体时间同步更新大家好，我是【高省】最大团队创始人珊珊，至于我为何用高省APP领取优惠券呢，当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百
• 我是谜《最后的自白》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为我是谜《最后的自白》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复我是谜《最后的自白》即可获取查看我是谜《最后的自白》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
• 剧本杀《白夜》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为剧本杀《白夜》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复剧本杀《白夜》即可获取查看剧本杀《白夜》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑------------------------------------------------------------------------剧本杀《白
• C语言学习 - continue跳转语句 Hyso
  continue跳转语句的使用用于for循环语句、while循环语句、dowhile循环语句中，跳过本次循环中剩余的语句而执行下一次循环。continue跳转语句的实例：#includeintmain(coid){intsum=0;inti=1;while(i<=100){sum+=i;i++;if(i==50){continue;}printf("i=%d\n",i);}printf("sum=
• 京东优惠卷攻略:这些京东优惠卷原来是这么领取的 一起高省
  嘿，小伙伴们！你们是不是经常在京东上眼馋那些打折商品，却总是苦于找不到优惠券而错过省钱的机会？别担心，我来给你们揭秘京东优惠券的领取秘籍，让你们轻松成为省钱达人！【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，是2021年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。高省是公认的返利最高的软件
• 剧本杀【死者在幻夜中醒来】复盘解析+凶手是谁+剧透结局+真相答案 VX搜_小燕子复盘
  哈喽大家好，很幸运您能刷到本篇文章，如果您想知道《死者在幻夜中醒来》剧本杀角色解析，《死者在幻夜中醒来》剧本杀真相结局，或者《死者在幻夜中醒来》剧本杀复盘答案，又或者《死者在幻夜中醒来》剧本杀剧透攻略等，那么本篇文章就能给您一个完美的答案，是不是已经迫不及待想知道答案了呢，那就赶紧往下看吧！为了你获得更好的游戏体验，本文仅显示《死者在幻夜中醒来》剧本杀部分真相复盘，获取完整真相复盘只需两步①【微信
• 黄金周长假节日瘦身攻略（2） 佳佳爱健身
  佳佳爱健身20180427周五Day020一、早起时间：5：09二、每日三目标：1、身材管理硬本领修炼2小时（饮食、运动、心理、睡眠）；2、健身房运动2小时；3、做减肥食谱1小时。三、小确幸：研究Hi式复盘法1小时。四、每日复盘：1、关键词：减肥假期送礼2、标题：黄金周长假节日瘦身攻略（2）（1）记录：马上要到五一黄金周小长假了，有的小伙伴要出游，有的小伙伴要聚会。每次节后做减肥咨询时，大家无非都
• 剧本杀《误入杀手镇的0和1》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为剧本杀《误入杀手镇的0和1》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复剧本杀《误入杀手镇的0和1》即可获取查看剧本杀《误入杀手镇的0和1》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------
• 百变大侦探《长恨歌·番外篇》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为百变大侦探《长恨歌·番外篇》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复百变大侦探《长恨歌·番外篇》即可获取查看百变大侦探《长恨歌·番外篇》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------
• 阿里云服务器ECS试用攻略，阿里云个人与企业试用云服务器介绍 阿里云最新优惠和活动汇总
  一直以来，阿里云都在尽全力帮助您更好地使用云服务器，现在，阿里云为我们提供1个月试用服务，您可在一个月内免费使用云服务器，帮助实现您的业务需求。个人和企业用户均可以申请试用，个人用户可以申请基础版试用，企业用户可以申请企业版试用，下面是阿里云服务器ECS试用攻略，分为个人版和企业版。个人版试用攻略（基础版试用）适合用户：学生、个人、初创企业试用规格：新手上云1-4核产品任您选试用台数：支持1台、多
• 剧本杀谁是凶手《落乡疑案》凶手是谁剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为谁是凶手《落乡疑案》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复谁是凶手《落乡疑案》即可获取查看谁是凶手《落乡疑案》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------------
• 叠加优惠享受更低价格：淘宝优惠券叠加使用攻略 浮沉导师
  淘宝作为中国最大的电子商务平台之一，为了吸引更多的消费者，提供了丰富的优惠券政策。对于购物者来说，叠加使用优惠卷可以进一步降低商品价格，提升购物体验。那么，接下来让我们详细了解一下淘宝优惠卷的叠加设置方法和相关注意事项。什么是淘宝优惠卷叠加？淘宝优惠卷叠加是指在购物过程中，同时使用多张优惠卷的一种方式。当多张优惠卷叠加时，可以享受更高的折扣和更低的价格。然而，并非所有的优惠卷都可以叠加使用，具体情
• 没有红叶的香山 真胡思乱想
  图片发自App图片发自App图片发自App图片发自App10月8号跑北京去旅游了，因为想错开高峰期，毕竟我不太喜欢在人太多的时候旅游，满是人得地方很多景色都被挡住了，看不到风景，全是忍，而且很多东西都需要排队，人太多浪费时间没必要，所以在10月8号去了北京。这时候的北京清净了许多，本身没准备去香山的，但是离着我本身的目的地比较近，所以决定去看看，可惜本身没看攻略，红叶要等再过一个月才红，门票不贵，
• Python库之Numpy的简介、安装、使用方法详细攻略 shadowtalon Pythonpythonnumpy开发语言
  Python库之Numpy的简介、安装、使用方法详细攻略引言在Python的数据处理和科学计算领域，Numpy库无疑是最核心的库之一。它提供了高性能的多维数组对象和一系列用于操作这些数组的工具。本篇文章将详细介绍Numpy的基本概念、安装方法以及如何使用Numpy进行数据处理。一、Numpy简介1.1什么是NumpyNumpy（NumericalPython）是一个开源的Python科学计算库，它
• Python库之PyAutoGUI的简介、安装、使用方法详细攻略 shadowtalon 爬虫Pythonpython爬虫学习开发语言
  Python库之PyAutoGUI的简介、安装、使用方法详细攻略简介PyAutoGUI是一个Python模块，它可以用来控制鼠标和键盘，实现自动化操作用户界面的功能。它适用于Windows、macOS和Linux操作系统。PyAutoGUI可以用于自动化测试、数据录入、自动化演示等场景。安装PyAutoGUI可以通过pip命令轻松安装。打开你的命令行工具（例如CMD、Terminal或者shell
• 百变大侦探【人间客】攻略+答案+凶手是谁+复盘解析+剧透结局 VX搜_彤彤速递
  每天持续更新复盘有15000＋：线下剧本杀·百变大侦探·我是谜·谁是凶手·玩吧·剧本杀线上·戏精大侦探·儿童剧本杀·魔王杀...所有谜题在等着你去揭开。为了你获得更好的游戏体验，本文仅显示《人间客》百变大侦探部分真相复盘，获取完整真相复盘只需两步①【微信关注公众号：云云复盘】②回复【人间客】即可查看获取哦百变《人间客》剧本杀攻略Ⅰ答案Ⅰ复盘剧本角色推荐6人本，边缘角色念生、抗压角色杨意寻·cp线故
• CTF——web方向学习攻略 一则孤庸 CTF网络安全CTF
  1计算机基础操作系统：熟悉Linux命令，方便使用Kali。网络技术：HCNA、CCNA。编程能力：拔高项，有更好。2web应用HTTP协议：必须掌握web开发框架web安全测试3数据库数据库基本操作SQL语句数据库优化4刷题
• 百变大侦探《镜世与灵犀》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为百变大侦探《镜世与灵犀》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复百变大侦探《镜世与灵犀》即可获取查看百变大侦探《镜世与灵犀》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------------
• 2022双十一省钱攻略(最全)_双十一怎么买省钱 高省_飞智666600
  今年的双十一活动即将开始，又到了我们囤东西薅羊毛的日子了，今年的双十一各大平台依旧推出了超大的优惠，那双十一怎样买最省钱？下面请看2022双十一省钱攻略大揭秘，跟着小编一起轻松玩转双十一！活动期间，天猫及淘宝平台将发放双十一超级红包(打开手机淘宝搜索：红包到手11100双十一怎样买最省钱？1.签到红包：3元红包2.芭芭农场：集阳光兑换满60-8或满70-10红包(指定页面下单)3.家电价格都高，付
• 剧本杀谁是凶手《连理枝》凶手是谁剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为谁是凶手《连理枝》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复谁是凶手《连理枝》即可获取查看谁是凶手《连理枝》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑-----------------------------------------------------------------------
• 百变大侦探《一汀烟雨杏花寒》剧本杀剧透+真相答案复盘解析攻略 VX搜_奶茶剧本杀
  本文为百变大侦探《一汀烟雨杏花寒》剧本杀测评+部分真相复盘，获取完整真相复盘只需两步：①、关注微信公众号【奶茶剧本杀】→②、回复百变大侦探《一汀烟雨杏花寒》即可获取查看百变大侦探《一汀烟雨杏花寒》剧本杀真相答案复盘+凶手剧透：以下是玩家评测+部分关键证据，凶手，时间线，复盘解析，推理逻辑--------------------------------------------------------
• Linux下载压缩包：tar.gz、zip、tar.bz2格式全攻略 promise524 Linuxlinux运维服务器后端bashshell
  在Linux中，下载各种格式的压缩包（如.tar.gz、.zip、.tar.bz2等）通常使用命令行工具如wget和curl。1.使用wget下载压缩包wget是Linux中最常用的文件下载工具，支持HTTP、HTTPS、FTP等协议，可以直接从命令行下载文件。基本命令：wget[URL]下载.tar.gz文件wgethttps://test.com/archive.tar.gz此命令将从指定的U
• 枚举的构造函数中抛出异常会怎样 bylijinnan javaenum单例
  首先从使用enum实现单例说起。 为什么要用enum来实现单例？ 这篇文章（ http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 1.enum单例简单、容易，只需几行代码： public enum Singleton { INSTANCE;
• CMake 教程 aigo C++
  转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/   CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。 介绍：http://baike.baidu.com/view/1126160.htm 本文件不介绍CMake的基本语法，下面是篇不错的入门教程： http:
• cvc-complex-type.2.3: Element 'beans' cannot have character Cb123456 springWebgis
    cvc-complex-type.2.3: Element 'beans' cannot have character     Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
• jquery实例:随页面滚动条滚动而自动加载内容 120153216 jquery
  <script language="javascript"> $(function (){ var i = 4;$(window).bind("scroll", function (event){ //滚动条到网页头部的 高度，兼容ie,ff,chrome var top = document.documentElement.s
• 将数据库中的数据转换成dbs文件 何必如此 sqldbs
  旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 1)数据库生成表结构信息：         主要生成数据库配置文件(.conf文
• 在IBATIS中配置SQL语句的IN方式 357029540 ibatis
  在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： <select id="getForms" param
• Spring3 MVC 笔记（一） 7454103 springmvcbeanRESTJSF
           自从 MVC 这个概念提出来之后 struts1.X  struts2.X   jsf 。。。。。 这个view 层的技术一个接一个！ 都用过！不敢说哪个绝对的强悍！ 要看业务，和整体的设计！      最近公司要求开发个新系统！
• Timer与Spring Quartz 定时执行程序 darkranger springbean工作quartz
  有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date;
• 大端小端转换，le32_to_cpu 和cpu_to_le32 aijuans C语言相关
  大端小端转换，le32_to_cpu 和cpu_to_le32  字节序 http://oss.org.cn/kernel-book/ldd3/ch11s04.html         小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
• Nginx负载均衡配置实例详解 avords
  [导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。 负载均衡 先来简单了解一下什么是负载均衡
• 乱说的 houxinyou 框架敏捷开发软件测试
  从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！ 这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白. 不过感觉和程序开发语言差不多， 瀑布就是顺序，敏捷就是循环. 瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。 也可以把软件开发理
• 欣赏的价值——一个小故事 bijian1013 有效辅导欣赏欣赏的价值
  　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
• 包冲突问题的解决方法 bingyingao eclipsemavenexclusions包冲突
  包冲突是开发过程中很常见的问题： 其表现有： 1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就 抛如下异常： java.lang.NoClassDefFoundError: Could not in
• 【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j bit1129 Stream
  先来一段废话： 实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
• sudoku solver in Haskell bookjovi sudokuhaskell
  这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。   现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
• java apache ftpClient bro_feng java
  最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。 看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
• 读《研磨设计模式》-代码笔记-工厂方法模式 bylijinnan java设计模式
  声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 工厂方法模式：使一个类的实例化延迟到子类 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）： * 有很多不同的产品，它
• 面试记录语 chenyu19891124 招聘
  或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。 今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
• Fire Workflow 1.0正式版终于发布了 comsci 工作workflowGoogle
  Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 官方网站是 http://www.fireflow.org 经过大家努力,Fire Workflow 1.0正式版终于发布了 正式版主要变化: 1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 2、增加IT
• Python向脚本传参 daizj python脚本传参
  如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？ 需要模块：sys 参数个数：len(sys.argv) 脚本名：    sys.argv[0] 参数1：     sys.argv[1] 参数2：     sys.argv[
• 管理用户分组的命令gpasswd dongwei_6688 passwd
  NAME： gpasswd - administer the /etc/group file SYNOPSIS： gpasswd group gpasswd -a user group gpasswd -d user group gpasswd -R group gpasswd -r group gpasswd [-A user,...] [-M user,...] g
• 郝斌老师数据结构课程笔记 dcj3sjt126com 数据结构与算法
  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
• yii2 cgridview加上选择框进行操作 dcj3sjt126com GridView
  页面代码 <?=Html::beginForm(['controller/bulk'],'post');?> <?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
• linux mysql fypop linux
  enquiry mysql version in centos linux yum list installed | grep mysql yum -y remove mysql-libs.x86_64 enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* install mysq
• Scramble String hcx2013 String
  Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. Below is one possible representation of s1 = "great":
• 跟我学Shiro目录贴 jinnianshilongnian 跟我学shiro
  历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。     ----广告-----------------------------------------------------
• nginx日志切割并使用flume-ng收集日志 liyonghui160com
       nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
• Oracle死锁解决方法 pda158 oracle
  　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
• java之List排序 shiguanghui list排序
     在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。 　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
• servlet单例多线程 utopialxw 单例多线程servlet
  转自http://www.cnblogs.com/yjhrem/articles/3160864.html 和   http://blog.chinaunix.net/uid-7374279-id-3687149.html Servlet 单例多线程 Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的

按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.