基础了解(十五)

在 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;

}

基础了解(十一)

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

// malloc 需要stdlib.h 勿忘使用free()来释放内存，否则可能引起内存泄漏
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    // 分配指定字节数的内存空间，返回void指针(内存的第一个字节的地址)，可强转成任何类型的指针
    // 分配失败返回空指针
    // 申请30个double类型值的空间
    double * ptd;
    ptd = (double *)malloc(30 * sizeof(double));
    *ptd = 3.14;
    ptd[1] = 222.222;
    //输出3.14和222.22
    printf("%.2f\n%.2f", *ptd, ptd[1]);
    return 0;
}

// malloc(字节数) free(malloc返回的指针) 需要stdlib.h
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    int *ptd;
    int max;
    int i = 0;
    puts("pls key a array size");
    scanf("%d", &max);
    // 利用malloc可以创建动态长度的数组
    ptd = (int *) malloc(max * sizeof(int));
    // NULL空指针，表示分配内存失败
    if (ptd == NULL)
    {
        puts("null point");
        return 1;
    }
    puts("pls key the array values");
    // scanf返回值 a.正整数(正确输入参数的个数) b.0(用户输入不匹配) c.EOF(stdio.h里面定义的常量（通常值为-1），表示输入流已经结束)
    while(i < max && scanf("%d", &ptd[i]) == 1)
    {
        ++i;
    }
    for (i = 0; i < max; ++i)
    {
        printf("%d\n", ptd[i]);
    }
    puts("done");
    // 释放内存
    free(ptd);
    return 0;
}

// calloc(num, B)
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const * argv[])
{
    int * p;
    // 与malloc()类似，只是calloc()多了个参数，表示所需分配内存单元的数量
    // calloc()还有个特性就是所有分配的内存单元默认为0(某些硬件系统，浮点值0不是用全部位为0来表示的)
    p = (int *) calloc(10, sizeof(int));
    // calloc()也是用free()释放内存空间的
    free(p);
    return 0;
}

// volatile限定词 易变的
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // 限定词volatile告诉编译器该变量除了可被程序改变外还可以被其他代理改变。
    // 典型地，它被用于硬件地址和与其他并行运行的程序共享的数据。
    // 如：一个地址可能保存着当前的时钟时间，另一种情况是一个地址被用来接收来自其他计算器的信息。
    volatile int loc1;      //loc1是一个易变的位置
    volatile int * ploc;    //ploc指向一个易变的位置
    return 0;
}

// 可能受其他代理影响的变量建议使用volatile关键字
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // 一些聪明的(优化的)编译器可能注意到两次使用了x，而没有改变它的值
    // 它将x临时存放在一个寄存器中，当val2需要x时，直接从寄存器中读取以节省时间(这个过程被称为缓存)
    // 通常，缓存是一个好的优化方式，但如果在两个语句中其他代理改变了x的话就不是这样了
    // 如果你没有使用volatile关键字来限定一个可能变化的值，编译器会试着优化代码
    val1 = x;
    /*
        ...
        中间是一些不使用x的代码
        ...
     */
    val2 = x;
    // const和volatile可以同时声明，前后顺序无所谓
    volatile const int nowTime;
    const volatile int * changePoint;
    return 0;
}

// restrict
#include <stdio.h>
int main(int argc, char const *argv[])
{
    //restrict关键字通过允许编译器优化某几种代码增强了计算支持
    //它只可用于指针，并表明指针是访问一个数据对象的唯一且初始方式
    // 这里，指针restar是由malloc()分配的内存的唯一且初始化的方式
    // par指针既不是初始化也不是访问数组ar中数据的唯一方式
    // 所以不可以把它限定为restrict
    int ar[10];
    int * restrict restar = (int *) malloc (10 * sizeof(int));
    int * par = ar;
    // 用了restrict关键字后，编译器可以试着优化代码 将restar[i]+=3和restar[i]+=5合并成restar[i]+=8
    // 而没有使用restrict关键字，编译器就不会优化代码，因为可能会有其他标识符可以改变数据的值，如：ar[i] *= 2;
    int i;
    for (i = 0; i < 10; ++i)
    {
        par[i] +=5;
        restar[i] +=5;
        ar[i] *= 2;
        par[i] +=3;
        restar[i] +=3;
    }
    // C库中有2个如下函数(都是复制内存用的)
    // memcpy()从位置s2把n个字节复制到s1,要求两个位置之间不重叠，但memmove()没这个要求
    // 所以 memcpy()的参数中使用了restrict关键字
    void * memcpy(void * restrict s1, const void * restrict s2, size_t n);
    void * memmove(void * s1, const void * s2, size_t n);
    return 0;
}

// 旧关键字新位置
#include <stdio.h>
int main(int argc, char const *argv[])
{
    void ofmouth(int * const a1, int * restrict a2, int n);     //以前的风格
    void ofmouth(int a1[const], int a2[restruct], int n);       //C99允许
    //使用static表明函数调用中，实际参数是一个指向数组首元素的指针
    //该数组至少有20个元素，这样做的目的是
    //1.告诉编译器可以自由地做一些有关优化的假定
    //2.告诉用户仅使用满足static要求的参数
    double stick(double ar[static 20]);
    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

// malloc 需要stdlib.h 勿忘使用free()来释放内存，否则可能引起内存泄漏

#include <stdio.h>

#include <stdlib.h>

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

{

// 分配指定字节数的内存空间，返回void指针(内存的第一个字节的地址)，可强转成任何类型的指针

// 分配失败返回空指针

// 申请30个double类型值的空间

double * ptd;

ptd = (double *)malloc(30 * sizeof(double));

*ptd = 3.14;

ptd[1] = 222.222;

//输出3.14和222.22

printf("%.2f\n%.2f", *ptd, ptd[1]);

return 0;

}

// malloc(字节数) free(malloc返回的指针) 需要stdlib.h

#include <stdio.h>

#include <stdlib.h>

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

{

int *ptd;

int max;

int i = 0;

puts("pls key a array size");

scanf("%d", &max);

// 利用malloc可以创建动态长度的数组

ptd = (int *) malloc(max * sizeof(int));

// NULL空指针，表示分配内存失败

if (ptd == NULL)

{

puts("null point");

return 1;

}

puts("pls key the array values");

// scanf返回值 a.正整数(正确输入参数的个数) b.0(用户输入不匹配) c.EOF(stdio.h里面定义的常量（通常值为-1），表示输入流已经结束)

while(i < max && scanf("%d", &ptd[i]) == 1)

{

++i;

}

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

{

printf("%d\n", ptd[i]);

}

puts("done");

// 释放内存

free(ptd);

return 0;

}

// calloc(num, B)

#include <stdio.h>

#include <stdlib.h>

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

{

int * p;

// 与malloc()类似，只是calloc()多了个参数，表示所需分配内存单元的数量

// calloc()还有个特性就是所有分配的内存单元默认为0(某些硬件系统，浮点值0不是用全部位为0来表示的)

p = (int *) calloc(10, sizeof(int));

// calloc()也是用free()释放内存空间的

free(p);

return 0;

}

// volatile限定词易变的

#include <stdio.h>

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

{

// 限定词volatile告诉编译器该变量除了可被程序改变外还可以被其他代理改变。

// 典型地，它被用于硬件地址和与其他并行运行的程序共享的数据。

// 如：一个地址可能保存着当前的时钟时间，另一种情况是一个地址被用来接收来自其他计算器的信息。

volatile int loc1; //loc1是一个易变的位置

volatile int * ploc; //ploc指向一个易变的位置

return 0;

}

// 可能受其他代理影响的变量建议使用volatile关键字

#include <stdio.h>

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

{

// 一些聪明的(优化的)编译器可能注意到两次使用了x，而没有改变它的值

// 它将x临时存放在一个寄存器中，当val2需要x时，直接从寄存器中读取以节省时间(这个过程被称为缓存)

// 通常，缓存是一个好的优化方式，但如果在两个语句中其他代理改变了x的话就不是这样了

// 如果你没有使用volatile关键字来限定一个可能变化的值，编译器会试着优化代码

val1 = x;

...

中间是一些不使用x的代码

...

val2 = x;

// const和volatile可以同时声明，前后顺序无所谓

volatile const int nowTime;

const volatile int * changePoint;

return 0;

}

// restrict

#include <stdio.h>

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

{

//restrict关键字通过允许编译器优化某几种代码增强了计算支持

//它只可用于指针，并表明指针是访问一个数据对象的唯一且初始方式

// 这里，指针restar是由malloc()分配的内存的唯一且初始化的方式

// par指针既不是初始化也不是访问数组ar中数据的唯一方式

// 所以不可以把它限定为restrict

int ar[10];

int * restrict restar = (int *) malloc (10 * sizeof(int));

int * par = ar;

// 用了restrict关键字后，编译器可以试着优化代码将restar[i]+=3和restar[i]+=5合并成restar[i]+=8

// 而没有使用restrict关键字，编译器就不会优化代码，因为可能会有其他标识符可以改变数据的值，如：ar[i] *= 2;

int i;

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

{

par[i] +=5;

restar[i] +=5;

ar[i] *= 2;

par[i] +=3;

restar[i] +=3;

}

// C库中有2个如下函数(都是复制内存用的)

// memcpy()从位置s2把n个字节复制到s1,要求两个位置之间不重叠，但memmove()没这个要求

// 所以 memcpy()的参数中使用了restrict关键字

void * memcpy(void * restrict s1, const void * restrict s2, size_t n);

void * memmove(void * s1, const void * s2, size_t n);

return 0;

}

// 旧关键字新位置

#include <stdio.h>

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

{

void ofmouth(int * const a1, int * restrict a2, int n); //以前的风格

void ofmouth(int a1[const], int a2[restruct], int n); //C99允许

//使用static表明函数调用中，实际参数是一个指向数组首元素的指针

//该数组至少有20个元素，这样做的目的是

//1.告诉编译器可以自由地做一些有关优化的假定

//2.告诉用户仅使用满足static要求的参数

double stick(double ar[static 20]);

return 0;

}

基础了解(十)

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

// 寄存器变量
#include <stdio.h>
void macho(register int n);     //允许
int wontwork(static int n);     //不允许
int main(int argc, char const *argv[])
{
    // 增加register关键字，"如果幸运" 变量就会被存放在CPU的寄存器中或速度最快的可用内存中
    // 寄存器变量能比普通变量更快的访问和操作，但是不能获取其地址
    // "如果幸运":声明寄存器变量是一个请求，而非一条直接的命令。编译器会根据你的请求和可用寄存器个数或
    // 可用高速内存的数量进行权衡，有可能会声明失败(仍然是普通变量，但是依然不能对它使用地址运算符)
    // 使用register声明的类型是有限的。例如：处理器可能没有足够大的寄存器来容纳double类型
    register int quick;
    return 0;
}

// extern关键字 具有外部链接的静态变量
#include <stdio.h>
int errupt;             //外部定义的变量
double up[100];         //外部定义的数组
extern char coal;       //如果coal是在其他文件中定义的变量，必须使用extern关键字再次声明
int main(int argc, char const *argv[])
{
    extern int errupt;      //可选的声明，只是表面main函数使用了这个变量
    extern double up[];     //可选的声明
    extern int errupt = 13; //错误，再次声明只是一个引用声明，而非定义声明
    int errupt;             //如果这样声明，main函数中会新建一个名为errupt的独立的自动变量
    return 0;
}

// 变量的默认值
#include <stdio.h>
int test;
int main(int argc, char const *argv[])
{
    int test1;
    static int test2;
    register int test3;
    // 静态变量会默认为0，非静态变量会取得垃圾值
    printf("%d\n%d\n%d\n%d", test, test1,test2, test3);
    getchar();
    return 0;
}

// 函数也具有存储类
#include <stdio.h>
double ganmma();            //默认为外部的
static double beta();       //内部，外部文件可以使用同名的不同函数。
extern double delta();      //外部
int main(int argc, char const *argv[])
{
    return 0;
}

// 随机数
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int mt_rand(int, int);
int main(int argc, char const *argv[])
{
    int i = mt_rand(0,5);
    printf("%d\n", i);
}
int mt_rand(int begin, int end)
{
    // 以当前时间戳为随机种子
    srand(time(0));
    return rand() % (end - begin + 1) + begin;
}

// 寄存器变量

#include <stdio.h>

void macho(register int n); //允许

int wontwork(static int n); //不允许

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

{

// 增加register关键字，"如果幸运" 变量就会被存放在CPU的寄存器中或速度最快的可用内存中

// 寄存器变量能比普通变量更快的访问和操作，但是不能获取其地址

// "如果幸运":声明寄存器变量是一个请求，而非一条直接的命令。编译器会根据你的请求和可用寄存器个数或

// 可用高速内存的数量进行权衡，有可能会声明失败(仍然是普通变量，但是依然不能对它使用地址运算符)

// 使用register声明的类型是有限的。例如：处理器可能没有足够大的寄存器来容纳double类型

return 0;

}

// extern关键字具有外部链接的静态变量

#include <stdio.h>

int errupt; //外部定义的变量

double up[100]; //外部定义的数组

extern char coal; //如果coal是在其他文件中定义的变量，必须使用extern关键字再次声明

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

{

extern int errupt; //可选的声明，只是表面main函数使用了这个变量

extern double up[]; //可选的声明

extern int errupt = 13; //错误，再次声明只是一个引用声明，而非定义声明

int errupt; //如果这样声明，main函数中会新建一个名为errupt的独立的自动变量

return 0;

}

// 变量的默认值

#include <stdio.h>

int test;

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

{

int test1;

static int test2;

// 静态变量会默认为0，非静态变量会取得垃圾值

printf("%d\n%d\n%d\n%d", test, test1,test2, test3);

getchar();

return 0;

}

// 函数也具有存储类

#include <stdio.h>

double ganmma(); //默认为外部的

static double beta(); //内部，外部文件可以使用同名的不同函数。

extern double delta(); //外部

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

{

return 0;

}

// 随机数

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

int mt_rand(int, int);

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

{

int i = mt_rand(0,5);

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

}

int mt_rand(int begin, int end)

{

// 以当前时间戳为随机种子

srand(time(0));

return rand() % (end - begin + 1) + begin;

}

唐晓锋–BLOG

This is just a personal note.

月份：2016年6月

基础了解(十五)

基础了解(十四)

基础了解(十三)

基础了解(十二)

基础了解(十一)

基础了解(十)