基础了解(十七)

在 2016年6月21日2016年6月27日上张贴由 BestLove

// 运算符 ~ & | ^ >> << &= |= ^= >>= <<=
// 二进制、十进制、十六进制
// 位运算符、位字段
// 字符串累加（int数组合并成字符串）
#include <stdio.h>
int main(int argc, char const *argv[])
{
    /*
        十进制数        十六进制数       八进制数        二进制等价数
        0               0                0               0000
        1               1                1               0001
        2               2                2               0010
        3               3                3               0011
        4               4                4               0100   
        5               5                5               0101   
        6               6                6               0110
        7               7                7               0111
        8               8                10              1000
        9               9                11              1001   
        10              A                12              1010   
        11              B                13              1011
        12              C                14              1100
        13              D                15              1101
        14              E                16              1110   
        15              F                17              1111
    */
   
    //二进制反码或按位取反 ~      ~(10011010)表达式 (01100101)结果值
    char val = 2;                   //00000010
    unsigned char newVal = ~val;    //11111101
    // 输出 253
    printf("%d\n", newVal);   

    //位与(AND) &  两个操作数都为1结果才为1  (10010011) & (00111101) = (00010001)
    //位与赋值运算符 &=   val &= 0377 与 val = val & 0377等效
    
    //位或(OR) | 两个操作数任意一个为1结果就为1  (10010011) | (00111101) = (10111111)
    //位或赋值运算符 |=   val |= 0377 与 val = val | 0377等效
    
    //位异或 ^  两个操作数中只有一个为1结果才为1  (10010011) ^ (00111101) = (10101110)
    //位异或赋值运算符 ^=   val ^= 0377 与 val = val ^ 0377等效
    
    //左移 <<  将左侧操作数的值向左移动N位(由右侧操作数指定) 然后丢弃左边移出的操作数 并在右边填充0
    //(10001010) << 2 = (00101000) 向左移动2位 第1、2位被丢弃(左边) 末尾填充2个0(右边)
    //左移动赋值运算符 <<=
    
    //右移 >>  将左侧操作数的值向右移动N位(由右侧操作数指定) 然后丢弃右边移出的操作数
    //对于unsigned，使用0填充左边空出的位 对于signed，结果依赖于机器
    //(10001010) >> 2 = (00100010) | (11100010) 对于无符号肯定是(00100010)，有符号根据不同操作系统可能存在不同值
    //左移动赋值运算符 >>= 
    
    //移位运算符能提供快捷、高效(依赖于硬件)对2的幂的乘法和除法
    // number << n  number乘以2的n次幂
    // number >> n  如果number非负，number除以2的n次幂
    // 类似于十进制中移动小数点来乘以或者乘以10
    return 0;
}

//移位运算符用于较大的单位中提取多组比特位
#include <stdio.h>
#define BYTE_MASK 0xff      //对应二进制11111111
int main(int argc, char const *argv[])
{
    unsigned long color = 0x002a162f;   //对应二进制00101010 00010110 00101111
    unsigned char blue, green, red;
    red = color & BYTE_MASK;                    //001010100001011000101111 & 000000000000000011111111 = 00101111
    green = (color >> 8) & BYTE_MASK;           //000000000010101000010110 & 000000000000000011111111 = 00010110
    blue = (color >> 16) & BYTE_MASK;           //000000000000000000101010 & 000000000000000011111111 = 00101010
    printf("%d %d %d\n", red, green, blue);     //输出对应的10进制为47 22 42
    return 0;
}

// 位字段(bit field)是一个signed int 或 unsigned int中一组相邻的位(C99允许_Bool)
#include <stdio.h>
struct bit
{
    unsigned int a: 1;
    unsigned int b: 2;
    unsigned int c: 3;
    unsigned int d: 32;
} prnt;
int main(int argc, char const *argv[])
{
    // prnt.a的取值范围是0-1      1
    // prnt.b的取值范围是0-3      11
    // prnt.c的取值范围是0-8      111
    // 位长度不能超过32，int的最大长度(4字节*8，具体根据操作系统)
    prnt.a = 1;
    prnt.b = 3;
    prnt.c = 7;
    // 输出1 3 7 0 (默认0)
    printf("%d %d %d %d\n", prnt.a, prnt.b, prnt.c, prnt.d);
    return 0;
}

// 字符串累加INT数组
#include <stdio.h>
#define ARR_SIZE 5
#define TEL_SIZE 11
int main(int argc, char const *argv[])
{
    int arr[ARR_SIZE] = {8, 2, 1, 0, 3};
    int index[TEL_SIZE] = {2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};
    char tel[TEL_SIZE + 1];
    int i;
    for (i = 0; i < TEL_SIZE; ++i)
    {
        // + '0'可以将int转为char
        tel[i] = arr[index[i]] + '0';
    }
    // 结尾勿忘累加'\0'
    tel[TEL_SIZE] = '\0';
    puts(tel);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

// 运算符 ~ & | ^ >> << &= |= ^= >>= <<=

// 二进制、十进制、十六进制

// 位运算符、位字段

// 字符串累加（int数组合并成字符串）

#include <stdio.h>

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

{

十进制数十六进制数八进制数二进制等价数

0 0 0 0000

1 1 1 0001

2 2 2 0010

3 3 3 0011

4 4 4 0100

5 5 5 0101

6 6 6 0110

7 7 7 0111

8 8 10 1000

9 9 11 1001

10 A 12 1010

11 B 13 1011

12 C 14 1100

13 D 15 1101

14 E 16 1110

15 F 17 1111

//二进制反码或按位取反 ~ ~(10011010)表达式 (01100101)结果值

char val = 2; //00000010

unsigned char newVal = ~val; //11111101

// 输出 253

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

//位与(AND) & 两个操作数都为1结果才为1 (10010011) & (00111101) = (00010001)

//位与赋值运算符 &= val &= 0377 与 val = val & 0377等效

//位或(OR) | 两个操作数任意一个为1结果就为1 (10010011) | (00111101) = (10111111)

//位或赋值运算符 |= val |= 0377 与 val = val | 0377等效

//位异或 ^ 两个操作数中只有一个为1结果才为1 (10010011) ^ (00111101) = (10101110)

//位异或赋值运算符 ^= val ^= 0377 与 val = val ^ 0377等效

//左移 << 将左侧操作数的值向左移动N位(由右侧操作数指定) 然后丢弃左边移出的操作数并在右边填充0

//(10001010) << 2 = (00101000) 向左移动2位第1、2位被丢弃(左边) 末尾填充2个0(右边)

//左移动赋值运算符 <<=

//右移 >> 将左侧操作数的值向右移动N位(由右侧操作数指定) 然后丢弃右边移出的操作数

//对于unsigned，使用0填充左边空出的位对于signed，结果依赖于机器

//(10001010) >> 2 = (00100010) | (11100010) 对于无符号肯定是(00100010)，有符号根据不同操作系统可能存在不同值

//左移动赋值运算符 >>=

//移位运算符能提供快捷、高效(依赖于硬件)对2的幂的乘法和除法

// number << n number乘以2的n次幂

// number >> n 如果number非负，number除以2的n次幂

// 类似于十进制中移动小数点来乘以或者乘以10

return 0;

}

//移位运算符用于较大的单位中提取多组比特位

#include <stdio.h>

#define BYTE_MASK 0xff //对应二进制11111111

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

{

unsigned long color = 0x002a162f; //对应二进制00101010 00010110 00101111

unsigned char blue, green, red;

red = color & BYTE_MASK; //001010100001011000101111 & 000000000000000011111111 = 00101111

green = (color >> 8) & BYTE_MASK; //000000000010101000010110 & 000000000000000011111111 = 00010110

blue = (color >> 16) & BYTE_MASK; //000000000000000000101010 & 000000000000000011111111 = 00101010

printf("%d %d %d\n", red, green, blue); //输出对应的10进制为47 22 42

return 0;

}

// 位字段(bit field)是一个signed int 或 unsigned int中一组相邻的位(C99允许_Bool)

#include <stdio.h>

struct bit

{

unsigned int a: 1;

unsigned int b: 2;

unsigned int c: 3;

unsigned int d: 32;

} prnt;

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

{

// prnt.a的取值范围是0-1 1

// prnt.b的取值范围是0-3 11

// prnt.c的取值范围是0-8 111

// 位长度不能超过32，int的最大长度(4字节*8，具体根据操作系统)

prnt.a = 1;

prnt.b = 3;

prnt.c = 7;

// 输出1 3 7 0 (默认0)

printf("%d %d %d %d\n", prnt.a, prnt.b, prnt.c, prnt.d);

return 0;

}

// 字符串累加INT数组

#include <stdio.h>

#define ARR_SIZE 5

#define TEL_SIZE 11

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

{

int arr[ARR_SIZE] = {8, 2, 1, 0, 3};

int index[TEL_SIZE] = {2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};

char tel[TEL_SIZE + 1];

int i;

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

{

// + '0'可以将int转为char

tel[i] = arr[index[i]] + '0';

}

// 结尾勿忘累加'\0'

tel[TEL_SIZE] = '\0';

puts(tel);

return 0;

}

基础了解(十六)

在 2016年6月21日2016年6月21日上张贴由 BestLove

//伸缩型数组成员必须是最后一个数组成员
//结构中必须至少有一个其他成员
//伸缩型数组就像普通数组一样被声明，除了它的方括号内是空的
#include <stdio.h>
struct flex
{
    int count;
    double average;
    double scores[];    //伸缩型数组成员
};
int main(int argc, char const *argv[])
{
    // 假设想要用scores表示含有5个double型数值的数组
    struct flex * pf;
    pf = malloc(sizeof(struct flex) + 5 * sizeof(double));
    return 0;
}

//union联合是一个能在同一存储空间(但不同时)存储不同类型数据的数据类型
#include <stdio.h>
union hold {
    int digit;
    double bigfl;
    char letter;
};
int main(int argc, char const *argv[])
{
    //编译器分配足够的空间以保存所描述的可能性的最大描述
    union hold fit;         //hold类型联合变量    最大可能double 8字节(根据操作系统)
    union hold save[10];    //10个联合变量的数组  10个8字节
    union hold * pu;        //指向hold类型变量的指针
    union hold valA;
    valA.letter = 'R';
    union hold valB = valA;                 //把一个联合初始化为另一个联合
    union hold valC = {88};                 //初始化联合的digit成员
    union hold valD = {.bigfl = 118.2};     //指定初始化项目
    fit.digit = 23;         //把23存储在fit中，使用2个字节
    fit.bigfl = 2.0;        //清除23，存储2.0，使用8个字节
    fit.letter = 'h';       //清除2.0，存储'h'，使用1个字节
    return 0;
}

//enum枚举
#include <stdio.h>
enum spectrum {red, orange, yellow, green, blue, violet};
enum spectrum color;
enum levels {low = 100, medium = 500, high = 2000};
enum feline {cat, lynx = 10, puma, tiger};
enum feline animal;
int main(int argc, char const *argv[])
{
    color = blue;
    // 输出4   默认：0,1,2,3,4,5
    printf("%d\n", color);
    enum levels level;
    level = low;
    // 输出100
    printf("%d\n", level);
    animal = puma;
    // 输出11
    printf("%d\n", animal);
    return 0;
}

// namespace命名空间
#include <stdio.h>
// 结构标记、联合标记、枚举标记和普通变量的命名空间是不同的
// 所以在C中可以定义如下2个rect不会冲突，但是不要这么做
// 1.相同名字容易造成混乱  2.C++中不允许这么做
struct rect
{
    double x;
    double y;
};
int rect;
int main(int argc, char const *argv[])
{
    return 0;
}

// typedef工具是一个高级数据特性，它使你能够为某一类型创建自己的名字
// 在这个方面，它和#define相似，但是它们具有3个不同之处
// 与#define不同，typedef给出的符号名称仅限于对类型，而不是对值
// typedef的解释由编译器，而不是预处理器执行
// 虽然它的范围有限，但在其受限范围内，typedef比#define更灵活
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // 自定义变量名BYTE(通常是大写)表示一个字符
    typedef unsigned char BYTE;
    // 为一个已经存在的类型创建一个名字可能看起来没什么必要，然而这可能是有用的
    // 比如time()的返回值是time_t类型，C标准规范应返回整数类型
    // 但它留给具体的实现来决定到底是哪种整数类型
    time_t time(time_t *);
    // 在一个系统上time_t可能是unsigned int，在另外个系统上可能是unsigned long
    // 只要包含了time.h头文件，程序就可以访问适当的定义
    // 使用#define可以实现typedef的一部分功能
    #define BYTE unsigned char
    // 但也有#define实现不了的功能
    typedef char * STRING;
    STRING name,sign;       //意思是 char * name, * sign;
    // 但如果这么做
    #define STRING char *
    STRING name, sign;      //将会被翻译成char * name, sign;
    // 可以对结构使用typedef
    typedef struct complex      //使用typedef来命名一个结构是，结构的标记可以省去(complex可以不写)
    {
        float real;
        float imag;
    } COMPLEX;
    COMPLEX c1;
    // 把FRPTC声明为一个函数类型，返回一个指向含有5个元素的char数组的指针
    typedef char(* FRPTC())[5];
    return 0;
}

// [] () * 优先级、函数指针
#include <stdio.h>
int main(int argc, char const *argv[])
{
    //[] () 具有相同的优先级(从左到右进行结合)，高于 * 的优先级
    int * risks[10];        //risks是一个指针数组(10个指针)
    int goods[12][50];      //12个具有50个int值的数组构成的数组
    int (* rusks)[10];      //rusks是一个指向具有10个int值的数组的指针(1个指针)
    int * off[3][4];        //3个由4个指向int指针的数组构成的数组(12个指针)
    int (*uuf)[3][4];       //指向3x4的int数组的指针(1个指针)
    char * fump();          //返回指向char指针的函数
    char (* frump)();       //指向返回char类型的函数的指针
    char (* flump[3])();    //由3个指针组成的数组，每个指针指向返回char类型的函数

    typedef int arr5[5];
    typedef arr5 * p_arr5;
    typedef p_arr5 arrp10[10];
    arr5 togs;      //togs是一个由5个int组成的数组
    p_arr5 p2;      //p2是一个指向5个int组成的数组的指针
    arrp10 ap;      //ap是一个10个元素的指针数组，每个指针指向5个int组成的数组
    // 指向函数的指针 要指出函数的返回类型和函数的参量类型
    void ToUpper(char *);
    void ToLower(char *);
    int round(double);
    void (*pf) (char *);    //pf是一个指向函数的指针 (char*)是函数的参量列表 void是返回类型
    pf = ToLower;           //合法，ToUpper是函数ToUpper()的地址
    pf = ToLower;           //合法，ToLower是函数ToLower()的地址
    pf = round;             //不合法，round是错误类型的函数
    pf = ToLower();         //不合法，ToLower()不是地址
    // 调用 语法1和语法2都可以
    char mis[] = "Nina Metier";
    (*pf)(mis);             //语法1 (*pf)就是pf指向的函数
    pf(mis);                //语法2 pf就是函数名
    // 将函数指针作为另一个函数的参数
    void show(void (*fp)(char *), char * str);
    show(ToLower, mis);         //可以传函数名，fp=ToLower
    show(pf, mis);              //可以传函数指针，fp=pf
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

//伸缩型数组成员必须是最后一个数组成员

//结构中必须至少有一个其他成员

//伸缩型数组就像普通数组一样被声明，除了它的方括号内是空的

#include <stdio.h>

struct flex

{

int count;

double average;

double scores[]; //伸缩型数组成员

};

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

{

// 假设想要用scores表示含有5个double型数值的数组

struct flex * pf;

pf = malloc(sizeof(struct flex) + 5 * sizeof(double));

return 0;

}

//union联合是一个能在同一存储空间(但不同时)存储不同类型数据的数据类型

#include <stdio.h>

union hold {

int digit;

double bigfl;

char letter;

};

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

{

//编译器分配足够的空间以保存所描述的可能性的最大描述

union hold fit; //hold类型联合变量最大可能double 8字节(根据操作系统)

union hold save[10]; //10个联合变量的数组 10个8字节

union hold * pu; //指向hold类型变量的指针

union hold valA;

valA.letter = 'R';

union hold valB = valA; //把一个联合初始化为另一个联合

union hold valC = {88}; //初始化联合的digit成员

union hold valD = {.bigfl = 118.2}; //指定初始化项目

fit.digit = 23; //把23存储在fit中，使用2个字节

fit.bigfl = 2.0; //清除23，存储2.0，使用8个字节

fit.letter = 'h'; //清除2.0，存储'h'，使用1个字节

return 0;

}

//enum枚举

#include <stdio.h>

enum spectrum {red, orange, yellow, green, blue, violet};

enum spectrum color;

enum levels {low = 100, medium = 500, high = 2000};

enum feline {cat, lynx = 10, puma, tiger};

enum feline animal;

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

{

color = blue;

// 输出4 默认：0,1,2,3,4,5

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

enum levels level;

level = low;

// 输出100

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

animal = puma;

// 输出11

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

return 0;

}

// namespace命名空间

#include <stdio.h>

// 结构标记、联合标记、枚举标记和普通变量的命名空间是不同的

// 所以在C中可以定义如下2个rect不会冲突，但是不要这么做

// 1.相同名字容易造成混乱 2.C++中不允许这么做

struct rect

{

double x;

double y;

};

int rect;

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

{

return 0;

}

// typedef工具是一个高级数据特性，它使你能够为某一类型创建自己的名字

// 在这个方面，它和#define相似，但是它们具有3个不同之处

// 与#define不同，typedef给出的符号名称仅限于对类型，而不是对值

// typedef的解释由编译器，而不是预处理器执行

// 虽然它的范围有限，但在其受限范围内，typedef比#define更灵活

#include <stdio.h>

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

{

// 自定义变量名BYTE(通常是大写)表示一个字符

typedef unsigned char BYTE;

// 为一个已经存在的类型创建一个名字可能看起来没什么必要，然而这可能是有用的

// 比如time()的返回值是time_t类型，C标准规范应返回整数类型

// 但它留给具体的实现来决定到底是哪种整数类型

time_t time(time_t *);

// 在一个系统上time_t可能是unsigned int，在另外个系统上可能是unsigned long

// 只要包含了time.h头文件，程序就可以访问适当的定义

// 使用#define可以实现typedef的一部分功能

#define BYTE unsigned char

// 但也有#define实现不了的功能

typedef char * STRING;

STRING name,sign; //意思是 char * name, * sign;

// 但如果这么做

#define STRING char *

STRING name, sign; //将会被翻译成char * name, sign;

// 可以对结构使用typedef

typedef struct complex //使用typedef来命名一个结构是，结构的标记可以省去(complex可以不写)

{

float real;

float imag;

} COMPLEX;

COMPLEX c1;

// 把FRPTC声明为一个函数类型，返回一个指向含有5个元素的char数组的指针

typedef char(* FRPTC())[5];

return 0;

}

// [] () * 优先级、函数指针

#include <stdio.h>

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

{

//[] () 具有相同的优先级(从左到右进行结合)，高于 * 的优先级

int * risks[10]; //risks是一个指针数组(10个指针)

int goods[12][50]; //12个具有50个int值的数组构成的数组

int (* rusks)[10]; //rusks是一个指向具有10个int值的数组的指针(1个指针)

int * off[3][4]; //3个由4个指向int指针的数组构成的数组(12个指针)

int (*uuf)[3][4]; //指向3x4的int数组的指针(1个指针)

char * fump(); //返回指向char指针的函数

char (* frump)(); //指向返回char类型的函数的指针

char (* flump[3])(); //由3个指针组成的数组，每个指针指向返回char类型的函数

typedef int arr5[5];

typedef arr5 * p_arr5;

typedef p_arr5 arrp10[10];

arr5 togs; //togs是一个由5个int组成的数组

p_arr5 p2; //p2是一个指向5个int组成的数组的指针

arrp10 ap; //ap是一个10个元素的指针数组，每个指针指向5个int组成的数组

// 指向函数的指针要指出函数的返回类型和函数的参量类型

void ToUpper(char *);

void ToLower(char *);

int round(double);

void (*pf) (char *); //pf是一个指向函数的指针 (char*)是函数的参量列表 void是返回类型

pf = ToLower; //合法，ToUpper是函数ToUpper()的地址

pf = ToLower; //合法，ToLower是函数ToLower()的地址

pf = round; //不合法，round是错误类型的函数

pf = ToLower(); //不合法，ToLower()不是地址

// 调用语法1和语法2都可以

char mis[] = "Nina Metier";

(*pf)(mis); //语法1 (*pf)就是pf指向的函数

pf(mis); //语法2 pf就是函数名

// 将函数指针作为另一个函数的参数

void show(void (*fp)(char *), char * str);

show(ToLower, mis); //可以传函数名，fp=ToLower

show(pf, mis); //可以传函数指针，fp=pf

return 0;

}

基础了解(十五)

在 2016年6月17日2016年6月20日上张贴由 BestLove

// 结构体可以赋值、也可以初始化为另一个结构体
// 结构体中字符串定义的区别
#include <stdio.h>
struct test
{
    char t1[31];
    int t2;
};
int main(int argc, char const *argv[])
{
    struct test test1 = {
        "zhangsan", 13
    };
    struct test test2 = test1;
    /*
        字符串存储在结构体内部
        struct names {
            char fname[LEN];
            char lname[LEN];
        };
        结构体内部只存放了2个字符串地址(只适用于在另外的地方已经为字符串分配了内存空间，例如：常量、数组中的字符串)
        struct names {
            char * fname;
            char * lname;
        };
     */
    return 0;
}

// 结构体内部存放字符串指针实例
#include <stdio.h>
#include <string.h>     //strcpy() strlen()
#include <stdlib.h>     //malloc() free()
struct namect
{
    char * fname;
    char * lname;
    int letters;
};
void getinfo(struct namect *);
void makeinfo(struct namect *);
void showinfo(const struct namect *);
void cleanup(struct namect *);
int main(int argc, char const *argv[])
{
    struct namect person;
    getinfo(&person);
    makeinfo(&person);
    showinfo(&person);
    cleanup(&person);
    return 0;
}
void getinfo(struct namect * pst)
{
    char temp[81];
    puts("Enter the fname");
    gets(temp);
    // 用来分配存放fname的内存
    pst->fname = (char *)malloc(strlen(temp) + 1);
    // 把fname复制到已分配的内存中
    strcpy(pst->fname, temp);
    puts("Enter the lname");
    gets(temp);
    pst->lname = (char *)malloc(strlen(temp) + 1);
    strcpy(pst->lname, temp);
}
void makeinfo(struct namect * pst)
{
    pst->letters = strlen(pst->fname) + strlen(pst->lname);
}
void showinfo(const struct namect * pst)
{
    printf("%s %s your name contains %d letters\n", pst->fname, pst->lname, pst->letters);
}
void cleanup(struct namect * pst)
{
    free(pst->fname);
    free(pst->lname);
}

// 结构体可以赋值、也可以初始化为另一个结构体

// 结构体中字符串定义的区别

#include <stdio.h>

struct test

{

char t1[31];

int t2;

};

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

{

struct test test1 = {

"zhangsan", 13

};

struct test test2 = test1;

字符串存储在结构体内部

struct names {

char fname[LEN];

char lname[LEN];

};

结构体内部只存放了2个字符串地址(只适用于在另外的地方已经为字符串分配了内存空间，例如：常量、数组中的字符串)

struct names {

char * fname;

char * lname;

};

return 0;

}

// 结构体内部存放字符串指针实例

#include <stdio.h>

#include <string.h> //strcpy() strlen()

#include <stdlib.h> //malloc() free()

struct namect

{

char * fname;

char * lname;

int letters;

};

void getinfo(struct namect *);

void makeinfo(struct namect *);

void showinfo(const struct namect *);

void cleanup(struct namect *);

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

{

struct namect person;

getinfo(&person);

makeinfo(&person);

showinfo(&person);

cleanup(&person);

return 0;

}

void getinfo(struct namect * pst)

{

char temp[81];

puts("Enter the fname");

gets(temp);

// 用来分配存放fname的内存

pst->fname = (char *)malloc(strlen(temp) + 1);

// 把fname复制到已分配的内存中

strcpy(pst->fname, temp);

puts("Enter the lname");

gets(temp);

pst->lname = (char *)malloc(strlen(temp) + 1);

strcpy(pst->lname, temp);

}

void makeinfo(struct namect * pst)

{

pst->letters = strlen(pst->fname) + strlen(pst->lname);

}

void showinfo(const struct namect * pst)

{

printf("%s %s your name contains %d letters\n", pst->fname, pst->lname, pst->letters);

}

void cleanup(struct namect * pst)

{

free(pst->fname);

free(pst->lname);

}

基础了解(十四)

在 2016年6月17日2016年6月20日上张贴由 BestLove

// struct union typedef . ->
#include <stdio.h>
#define MAXTITLE 41
#define MAXAUThOR 41
struct book
{
    char title[MAXTITLE];
    char author[MAXAUThOR];
    float pirce;
};
int main(int argc, char const *argv[])
{
    /*
        可以在函数内部定义
        可以省略标记book
        可以直接在定义之后跟变量名library
        struct book
        {
            char title[MAXTITLE];
            char author[MAXAUThOR];
            float pirce;
        } library;
     */
    struct book library;
    /*
        可以初始化
        struct book library = {
            "彼岸花",
            "安妮宝贝",
            1.01  
        };
        可以部分初始化
        struct book library = {
            .price = 1.01
        };
        可以乱序初始化
        struct book library = {
            .price = 1.01,
            .title = "彼岸花",
            .author = "安妮宝贝"
        };
        复合文字写法，复合文字也可以用作函数参数
        struct book library = (struct book){
            "彼岸花",
            "安妮宝贝",
            1.01  
        };
     */
    /*
        可以嵌套结构
        struct names {
            char first[LEN];
            char last[LEN];
        };
        struct guy {
            struct name handle;
            char favfood[LEN];
            char job[LEN];
            float income;
        };
    */
    puts("Enter the book title");
    gets(library.title);
    puts("Enter the book author");
    gets(library.author);
    puts("Enter the book pirce");
    scanf("%f", &library.pirce);
    printf("title:%s author:%s pirce:%.2f\n", library.title, library.author, library.pirce);
    return 0;
}

// 指向结构体的指针
#include <stdio.h>
#define LEN 20
struct names
{
    char first[LEN];
    char last[LEN];
};
struct guy
{
    struct names handle;
    char favfood[LEN];
    char job[LEN];
    float income;
};
int main(int argc, char const *argv[])
{
    struct guy fellow[2] = {
        {
            {"Ewen", "Villard"},
            "grilled salmon",
            "personality coach",
            58112.00
        },
        {
            {"Rodney", "Swillbelly"},
            "tripe",
            "tabloid editor",
            232400.00
        }
    };
    // 声明guy类型的指针
    struct guy * him;
    printf("address #1:%p #2:%p\n", &fellow[0], &fellow[1]);
    him = &fellow[0];
    printf("pointer #1:%p #2:%p\n", him, him + 1);
    // 指针->成员名 结构名.成员名 (*him).income必须用()，因为.的优先级比*高
    printf("him->income is $%.2f:(*him).income is $%.2f\n", him->income, (*him).income);
    him++;
    printf("him->favfood is %s:him->handle.last is %s\n", him->favfood, him->handle.last);
    return 0;
}

// 向函数传递结构信息
#include <stdio.h>
struct test
{
    double a;
    double b;
    char c;
    int d;
};
double sum1(double, double);
double sum2(const struct test *);
double sum3(struct test);
int main(int argc, char const *argv[])
{
    struct test test1 = {
        3.14,3.15,'a',10
    };
    // 向函数传递结构成员
    printf("%.2f\n", sum1(test1.a, test1.b));
    // 向函数传递结构指针，需要&(跟数组不同)
    printf("%.2f\n", sum2(&test1));
    // 对于支持结构体作为函数参数的编译器，也可以这么写
    printf("%.2f\n", sum3(test1));
    return 0;
}
double sum1(double a, double b)
{
    return a + b;
}
double sum2(const struct test * test1)
{
    return test1->a + test1->b;
}
double sum3(struct test test1)
{
    return test1.a + test1.b;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

// struct union typedef . ->

#include <stdio.h>

#define MAXTITLE 41

#define MAXAUThOR 41

struct book

{

char title[MAXTITLE];

char author[MAXAUThOR];

float pirce;

};

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

{

可以在函数内部定义

可以省略标记book

可以直接在定义之后跟变量名library

struct book

{

char title[MAXTITLE];

char author[MAXAUThOR];

float pirce;

} library;

struct book library;

可以初始化

struct book library = {

"彼岸花",

"安妮宝贝",

1.01

};

可以部分初始化

struct book library = {

.price = 1.01

};

可以乱序初始化

struct book library = {

.price = 1.01,

.title = "彼岸花",

.author = "安妮宝贝"

};

复合文字写法，复合文字也可以用作函数参数

struct book library = (struct book){

"彼岸花",

"安妮宝贝",

1.01

};

可以嵌套结构

struct names {

char first[LEN];

char last[LEN];

};

struct guy {

struct name handle;

char favfood[LEN];

char job[LEN];

float income;

};

puts("Enter the book title");

gets(library.title);

puts("Enter the book author");

gets(library.author);

puts("Enter the book pirce");

scanf("%f", &library.pirce);

printf("title:%s author:%s pirce:%.2f\n", library.title, library.author, library.pirce);

return 0;

}

// 指向结构体的指针

#include <stdio.h>

#define LEN 20

struct names

{

char first[LEN];

char last[LEN];

};

struct guy

{

struct names handle;

char favfood[LEN];

char job[LEN];

float income;

};

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

{

struct guy fellow[2] = {

{

{"Ewen", "Villard"},

"grilled salmon",

"personality coach",

58112.00

{

{"Rodney", "Swillbelly"},

"tripe",

"tabloid editor",

232400.00

}

};

// 声明guy类型的指针

struct guy * him;

printf("address #1:%p #2:%p\n", &fellow[0], &fellow[1]);

him = &fellow[0];

printf("pointer #1:%p #2:%p\n", him, him + 1);

// 指针->成员名结构名.成员名 (*him).income必须用()，因为.的优先级比*高

printf("him->income is $%.2f:(*him).income is $%.2f\n", him->income, (*him).income);

him++;

printf("him->favfood is %s:him->handle.last is %s\n", him->favfood, him->handle.last);

return 0;

}

// 向函数传递结构信息

#include <stdio.h>

struct test

{

double a;

double b;

char c;

int d;

};

double sum1(double, double);

double sum2(const struct test *);

double sum3(struct test);

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

{

struct test test1 = {

3.14,3.15,'a',10

};

// 向函数传递结构成员

printf("%.2f\n", sum1(test1.a, test1.b));

// 向函数传递结构指针，需要&(跟数组不同)

printf("%.2f\n", sum2(&test1));

// 对于支持结构体作为函数参数的编译器，也可以这么写

printf("%.2f\n", sum3(test1));

return 0;

}

double sum1(double a, double b)

{

return a + b;

}

double sum2(const struct test * test1)

{

return test1->a + test1->b;

}

double sum3(struct test test1)

{

return test1.a + test1.b;

}

基础了解(十三)

在 2016年6月17日2016年6月20日上张贴由 BestLove

//fwrite(const void * restrict ptr, size_t size, size_t nmemb, FILE * restrict fp);
//fwrite返回成功写入的项目数，正常情况下，它与nmemb相等，如果有写入错误，返回值将小于nmemb
#include <stdio.h>
int main(int argc, char const *argv[])
{
    //将一块256字节大小的数据从缓冲区写入到文件
    char buffer[256];
    fwrite(buffer, 256, 1, fp);
    //将earnings数组中的数据写入文件，数据分成10块，每块都是double大小
    double earnings[10];
    fwrite(earnings, sizeof(double), 10, fp);
    //fread(void * restrict ptr, size_t size, size_t nmemb, FILE * restrict fp);
    //fread返回成功读入的项目数，正常情况下，它与nmemb相等，如果有读取错误，返回值将小于nmemb
    double earnings[10];
    fread(earnings, sizeof(double), 10, fp);
    return 0;
}

// 利用fread() fwrite() setvbuf()来读取指定文件(可以多个)来追加目标文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BUFSIZE 1024
#define SLEN 81
void append(FILE *source, FILE *dest);
int main(void)
{
    // int setvbuf(FILE * restrict fp, char * restrict buf, int mode, size_t size);
    // setvbuf()函数建立一个供标准I/O函数使用的替代缓冲区(不使用fopen打开的默认缓冲区)
    // 当需要处理数据库、视频、音频、图像等大量需要爆发式磁盘到内存的I/O情况下可以考虑使用
    // 如果buf不是NULL，则必须创建这个缓冲区，例如一个1024字节的数组，然后传递该数组的地址
    // 如果buf为NULL，函数会自动malloc()一个缓冲区
    // mode取值范围如下：
    // _IOFBF:完全缓冲(缓冲区满的时候刷新)
    // _IOLBF:行缓冲(缓冲区满或一个新行写入的时候刷新)
    // _IONBF:无缓冲
    // size表示缓冲区的长度(必须大于0)
    // 返回值 成功：0 失败：非0
    FILE *fa, *fs;
    int files = 0;
    char file_app[SLEN];
    char file_src[SLEN];
    puts("Enter name of destination file:");
    gets(file_app);
    if ((fa = fopen(file_app, "a")) == NULL)
    {
        fprintf(stderr, "Can't open %s\n", file_app);
        exit(2);
    }
    if (setvbuf(fa, NULL, _IOFBF, BUFSIZE) != 0)
    {
        fputs("Can't create output buffer\n", stderr);
        exit(3);
    }
    puts("Enter name of first source file(empty line to quit):");
    while(gets(file_src) && file_src[0] != '\0')
    {
        if (strcmp(file_src, file_app) == 0)
        {
            fputs("Can't append file to itself\n", stderr);
        }
        else if((fs = fopen(file_src, "r")) == NULL)
        {
            fprintf(stderr, "Can't open%s\n", file_src);
        }
        else
        {
            if (setvbuf(fs, NULL, _IOFBF, BUFSIZE) != 0)
            {
                fputs("Can't create input buffer\n", stderr);
                fclose(fs);
                continue;
            }
            append(fs, fa);
            //当标准输入函数EOF时，通常表示已经达到了文件结尾，但也有可能表示发生了错误
            //使用feof() ferror()可以区分这两种可能性。
            //如果最近一次输入调用检测到文件结尾，feof()返回一个非0值，否则返回0值
            //如果发生了读写错误，ferror()返回非0值，否则返回0值
            if (ferror(fs) != 0)
            {
                fprintf(stderr, "Error in reading file%s\n", file_src);
                files--;
            }
            if (ferror(fa) != 0)
            {
                fprintf(stderr, "Error in writing file%s\n", file_app);
                files--;
            }
            fclose(fs);
            files++;
            printf("File%s appended\n", file_src);
            puts("Next file(empty line to quit):");
        }
    }
    printf("Done %d files appended\n", files);
    fclose(fa);
    return 0;
}
void append(FILE *source, FILE *dest)
{
    size_t bytes;
    static char temp[BUFSIZE];
    while((bytes = fread(temp, sizeof(char), BUFSIZE, source)) > 0)
    {
        fwrite(temp, sizeof(char), bytes, dest);
    }
}

// 随机读
#include <stdio.h>
#include <stdlib.h>
#define ARSIZE 1000
int main(int argc, char const *argv[])
{
    double numbers[ARSIZE];
    double value;
    const char * file = "numbers.dat";
    int i;
    long pos;
    FILE * iofile;
    for (i = 0; i < ARSIZE; ++i)
    {
        numbers[i] = 100.0 * i + 1.0 / (i+1);
    }
    if ((iofile = fopen(file, "wb")) == NULL)
    {
        fprintf(stderr, "Could not open %s for output\n", file);
        exit(1);
    }
    fwrite(numbers, sizeof(double), ARSIZE, iofile);
    fclose(iofile);
    if ((iofile = fopen(file, "rb")) == NULL)
    {
        fprintf(stderr, "Could not open %s for random access\n", file);
        exit(1);
    }
    printf("Enter an index in the range 0-%d\n", ARSIZE - 1);
    scanf("%d", &i);
    while(i >= 0 && i < ARSIZE)
    {
        pos = (long)i * sizeof(double);
        fseek(iofile, pos, SEEK_SET);
        fread(&value, sizeof(double), 1, iofile);
        printf("The value there is %f \n", value);
        printf("Next index (out of range to quit):\n");
        scanf("%d", &i);
    }
    fclose(iofile);
    puts("Done");
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

//fwrite(const void * restrict ptr, size_t size, size_t nmemb, FILE * restrict fp);

//fwrite返回成功写入的项目数，正常情况下，它与nmemb相等，如果有写入错误，返回值将小于nmemb

#include <stdio.h>

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

{

//将一块256字节大小的数据从缓冲区写入到文件

char buffer[256];

fwrite(buffer, 256, 1, fp);

//将earnings数组中的数据写入文件，数据分成10块，每块都是double大小

double earnings[10];

fwrite(earnings, sizeof(double), 10, fp);

//fread(void * restrict ptr, size_t size, size_t nmemb, FILE * restrict fp);

//fread返回成功读入的项目数，正常情况下，它与nmemb相等，如果有读取错误，返回值将小于nmemb

double earnings[10];

fread(earnings, sizeof(double), 10, fp);

return 0;

}

// 利用fread() fwrite() setvbuf()来读取指定文件(可以多个)来追加目标文件

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define BUFSIZE 1024

#define SLEN 81

void append(FILE *source, FILE *dest);

int main(void)

{

// int setvbuf(FILE * restrict fp, char * restrict buf, int mode, size_t size);

// setvbuf()函数建立一个供标准I/O函数使用的替代缓冲区(不使用fopen打开的默认缓冲区)

// 当需要处理数据库、视频、音频、图像等大量需要爆发式磁盘到内存的I/O情况下可以考虑使用

// 如果buf不是NULL，则必须创建这个缓冲区，例如一个1024字节的数组，然后传递该数组的地址

// 如果buf为NULL，函数会自动malloc()一个缓冲区

// mode取值范围如下：

// _IOFBF:完全缓冲(缓冲区满的时候刷新)

// _IOLBF:行缓冲(缓冲区满或一个新行写入的时候刷新)

// _IONBF:无缓冲

// size表示缓冲区的长度(必须大于0)

// 返回值成功：0 失败：非0

FILE *fa, *fs;

int files = 0;

char file_app[SLEN];

char file_src[SLEN];

puts("Enter name of destination file:");

gets(file_app);

if ((fa = fopen(file_app, "a")) == NULL)

{

fprintf(stderr, "Can't open %s\n", file_app);

exit(2);

}

if (setvbuf(fa, NULL, _IOFBF, BUFSIZE) != 0)

{

fputs("Can't create output buffer\n", stderr);

exit(3);

}

puts("Enter name of first source file(empty line to quit):");

while(gets(file_src) && file_src[0] != '\0')

{

if (strcmp(file_src, file_app) == 0)

{

fputs("Can't append file to itself\n", stderr);

}

else if((fs = fopen(file_src, "r")) == NULL)

{

fprintf(stderr, "Can't open%s\n", file_src);

}

else

{

if (setvbuf(fs, NULL, _IOFBF, BUFSIZE) != 0)

{

fputs("Can't create input buffer\n", stderr);

fclose(fs);

continue;

}

append(fs, fa);

//当标准输入函数EOF时，通常表示已经达到了文件结尾，但也有可能表示发生了错误

//使用feof() ferror()可以区分这两种可能性。

//如果最近一次输入调用检测到文件结尾，feof()返回一个非0值，否则返回0值

//如果发生了读写错误，ferror()返回非0值，否则返回0值

if (ferror(fs) != 0)

{

fprintf(stderr, "Error in reading file%s\n", file_src);

files--;

}

if (ferror(fa) != 0)

{

fprintf(stderr, "Error in writing file%s\n", file_app);

files--;

}

fclose(fs);

files++;

printf("File%s appended\n", file_src);

puts("Next file(empty line to quit):");

}

printf("Done %d files appended\n", files);

fclose(fa);

return 0;

}

void append(FILE *source, FILE *dest)

{

size_t bytes;

static char temp[BUFSIZE];

while((bytes = fread(temp, sizeof(char), BUFSIZE, source)) > 0)

{

fwrite(temp, sizeof(char), bytes, dest);

}

// 随机读

#include <stdio.h>

#include <stdlib.h>

#define ARSIZE 1000

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

{

double numbers[ARSIZE];

double value;

const char * file = "numbers.dat";

int i;

long pos;

FILE * iofile;

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

{

numbers[i] = 100.0 * i + 1.0 / (i+1);

}

if ((iofile = fopen(file, "wb")) == NULL)

{

fprintf(stderr, "Could not open %s for output\n", file);

exit(1);

}

fwrite(numbers, sizeof(double), ARSIZE, iofile);

fclose(iofile);

if ((iofile = fopen(file, "rb")) == NULL)

{

fprintf(stderr, "Could not open %s for random access\n", file);

exit(1);

}

printf("Enter an index in the range 0-%d\n", ARSIZE - 1);

scanf("%d", &i);

while(i >= 0 && i < ARSIZE)

{

pos = (long)i * sizeof(double);

fseek(iofile, pos, SEEK_SET);

fread(&value, sizeof(double), 1, iofile);

printf("The value there is %f \n", value);

printf("Next index (out of range to quit):\n");

scanf("%d", &i);

}

fclose(iofile);

puts("Done");

return 0;

}

基础了解(十二)

在 2016年6月15日2016年6月20日上张贴由 BestLove

/*
    文本模式、二进制模式  文本格式、二进制格式
    缓冲、非缓冲I/O  顺序存取、随机存取
    fopen() getc() putc() exit() fclose() fprintf() fscanf()
    fgets() fputs() rewind() fseek() ftell() fflush() fgetpos()
    fsetpos() feof() ferror() ungetc() setvbuf() fread() fwrite()
 */
// 文件输入/输出 getc() putc()
#include <stdio.h>
#include <stdlib.h>     //exit()
int main(int argc, char const *argv[])
{
    if (argc < 2)
    {
        puts("pls key the file name");
        return 1;
    }
    FILE * fp;
    FILE * fpout;
    fpout = fopen("./d.log", "w+");
    if ((fp = fopen(argv[1], "r")) == NULL)
    {
        puts("file no exists");
        // exit()可以关闭文件指针 可以使用宏常量 EXIT_SUCCESS EXIT_FAILURE
        exit(2);
    }
    char c;
    while( (c = getc(fp)) != EOF )
    {
        putc(c, stdout);
        putc(c, fpout);
    }
    // fclose()关闭文件指针，刷新缓冲区
    fclose(fp);
    fclose(fpout);
    // 更正规的程序也许还要检查是否成功关闭(磁盘满或被移走或出现I/O错误等会导致fclose()失败)
    if (fclose(fp) != 0 || fclose(fpout) != 0)
    {
        puts("fclose error");
    }
    return 0;
}

// fseek(fp,long offset,int start) ftell(fp)
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    FILE *fpin, *fpout;
    fpin = fopen("./a.php", "rb");
    fpout = fopen("./d.log", "a+");
    fseek(fpin, 0L, SEEK_END);
    long i;
    // ftell返回文件的当前位置，距文件开始处的字节数
    // 文件第一个字节到开始处的距离是字节0
    // 适用于二进制模式打开的文件，对于文本模式打开获取的值可能不正确(换行回车等)
    long last = ftell(fpin);
    char c;
    for (int i = 1L; i <= last; ++i)
    {
        // 偏移量为负表示回退
        // SEEK_SET：文件开始 SEEK_CUR：当前位置 SEEK_END：文件结尾
        // 返回值为0表示成功 -1表示失败
        fseek(fpin, -i, SEEK_END);
        c = getc(fpin);
        // 针对window平台 \r\n会输出两个换行，舍去一个
        // 不兼容mac，mac下\r表示换行
        if (c == '\r') continue;
        putc(c, fpout);
    }
    if (fclose(fpin) != 0 || fclose(fpout) != 0)
    {
        exit(1);
    }
    return 0;
}

// int fgetpos(fp, fpos_t * restrict pos) 成功返回0 失败返回非0值
// int fsetpos(fp, const fpos_t * pos) 成功返回0 失败返回非0值
// fpos_t：文件定位类型(file position type)，不能是数组类型
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // fseek()和ftell()的一个潜在问题是它们限制文件的大小只能在long类型的表示范围内
    FILE *p;
    fpos_t pos1;
    // 这里不能用a+ 因为用a+打开时，每次写文件都会被定位到文件的尾部
    // 但是a+可以累加输出，而w+会把打开时的内容清空
    // 例如本例：两次执行a.exe(w+) c.log中内容为：5234
    // 两次执行a.exe(a+) c.log中内容为：1234512345
    if((p = fopen("c.log", "w+")) == NULL)
    {
        printf("open file error");
        return 1;
    }
    // 获取一个定位点
    if(fgetpos(p, &pos1))
    {
        printf("get pos error");
        return 1;
    }
    fputs("1234", p);
    // 设置回刚才的定位点
    fsetpos(p, &pos1);
    // 最终输出5234,1被5替换掉了
    fputs("5", p);
    return 0;
}

100

101

102

103

104

105

106

107

108

文本模式、二进制模式文本格式、二进制格式

缓冲、非缓冲I/O 顺序存取、随机存取

fopen() getc() putc() exit() fclose() fprintf() fscanf()

fgets() fputs() rewind() fseek() ftell() fflush() fgetpos()

fsetpos() feof() ferror() ungetc() setvbuf() fread() fwrite()

// 文件输入/输出 getc() putc()

#include <stdio.h>

#include <stdlib.h> //exit()

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

{

if (argc < 2)

{

puts("pls key the file name");

return 1;

}

FILE * fp;

FILE * fpout;

fpout = fopen("./d.log", "w+");

if ((fp = fopen(argv[1], "r")) == NULL)

{

puts("file no exists");

// exit()可以关闭文件指针可以使用宏常量 EXIT_SUCCESS EXIT_FAILURE

exit(2);

}

char c;

while( (c = getc(fp)) != EOF )

{

putc(c, stdout);

putc(c, fpout);

}

// fclose()关闭文件指针，刷新缓冲区

fclose(fp);

fclose(fpout);

// 更正规的程序也许还要检查是否成功关闭(磁盘满或被移走或出现I/O错误等会导致fclose()失败)

if (fclose(fp) != 0 || fclose(fpout) != 0)

{

puts("fclose error");

}

return 0;

}

// fseek(fp,long offset,int start) ftell(fp)

#include <stdio.h>

#include <stdlib.h>

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

{

FILE *fpin, *fpout;

fpin = fopen("./a.php", "rb");

fpout = fopen("./d.log", "a+");

fseek(fpin, 0L, SEEK_END);

long i;

// ftell返回文件的当前位置，距文件开始处的字节数

// 文件第一个字节到开始处的距离是字节0

// 适用于二进制模式打开的文件，对于文本模式打开获取的值可能不正确(换行回车等)

long last = ftell(fpin);

char c;

for (int i = 1L; i <= last; ++i)

{

// 偏移量为负表示回退

// SEEK_SET：文件开始 SEEK_CUR：当前位置 SEEK_END：文件结尾

// 返回值为0表示成功 -1表示失败

fseek(fpin, -i, SEEK_END);

c = getc(fpin);

// 针对window平台 \r\n会输出两个换行，舍去一个

// 不兼容mac，mac下\r表示换行

if (c == '\r') continue;

putc(c, fpout);

}

if (fclose(fpin) != 0 || fclose(fpout) != 0)

{

exit(1);

}

return 0;

}

// int fgetpos(fp, fpos_t * restrict pos) 成功返回0 失败返回非0值

// int fsetpos(fp, const fpos_t * pos) 成功返回0 失败返回非0值

// fpos_t：文件定位类型(file position type)，不能是数组类型

#include <stdio.h>

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

{

// fseek()和ftell()的一个潜在问题是它们限制文件的大小只能在long类型的表示范围内

FILE *p;

fpos_t pos1;

// 这里不能用a+ 因为用a+打开时，每次写文件都会被定位到文件的尾部

// 但是a+可以累加输出，而w+会把打开时的内容清空

// 例如本例：两次执行a.exe(w+) c.log中内容为：5234

// 两次执行a.exe(a+) c.log中内容为：1234512345

if((p = fopen("c.log", "w+")) == NULL)

{

printf("open file error");

return 1;

}

// 获取一个定位点

if(fgetpos(p, &pos1))

{

printf("get pos error");

return 1;

}

fputs("1234", p);

// 设置回刚才的定位点

fsetpos(p, &pos1);

// 最终输出5234,1被5替换掉了

fputs("5", p);

return 0;

}

唐晓锋–BLOG

This is just a personal note.

基础了解(十七)

基础了解(十六)

基础了解(十五)

基础了解(十四)

基础了解(十三)

基础了解(十二)