基础了解(五)

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

// 数组
#include <stdio.h>
#define MONTHS 12;
int main(void)
{
    int a[6];
    int b[6] = {1, 2, 3, 4, 5, 6};
    int c[] = {1, 2, 3, 4, 5, 6};
    int d[6] = {1, 2, 3};
    // 只读数组，必须在声明时赋值
    const int e[2] = {1, 2};
    // 输出 24 and 24 and 6
    printf("%d and %d and %d\n", sizeof(a), sizeof(b), sizeof(b) / sizeof(b[0]));
    // 计算数组的长度
    int size = sizeof(b) / sizeof(b[0]);
    for (int i = 0; i < size; ++i)
    {
        // a会取内存中的脏值，b、c正常，d的后3位会默认为0
        printf("a=%-15d and b=%-15d and c=%-15d and d=%-15d\n", a[i], b[i], c[i], d[i]);
    }
    // 可以使用[index]来为指定的元素赋值
    int days[MONTHS] = {31, 28, [4] = 31, 30, 31, [1] = 29};
    getchar();
    return 0;
}

// 错误的数组赋值
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr1[4];
    int arr2[4] = {1, 2, 3, 4};
    //以下三种赋值方式都是错误的
    arr1 = arr2;
    arr1[4] = arr2[4];
    //花括号赋值只能用于初始化的时候
    arr1[4] = {1, 2, 3, 4};
    return 0;
}

// 数组与指针
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[4] = {1, 2, 3, 4};
    int rs;
    rs = arr == &arr[0];
    printf("%p and %p\n", arr, &arr[0]);
    // 输出1(true) 数组名是该数组首元素的地址
    printf("%d\n", rs);
    // 同理 arr+2 == &arr[2]  *(arr+2) == arr[2]
    getchar();
    return 0;
}

// 未初始化的指针赋值
#include <stdio.h>
int main(void)
{
    // 以下做法是不对的，把5放到pt所指向的地址，但是地址还没有被初始化
    int *pt;    //未初始化的指针
    *pt = 5;

    // 可以这么做
    int a;
    int *pt;
    pt = &a;
    *pt = 5;
    printf("%d %d\n", *pt, a);
    getchar();
    return 0;
}

// 比如数组求和，不需要修改数组原值，使用const可防止数组被误修改
#include <stdio.h>
int sum(const int[], int);
int main(int argc, char const *argv[])
{
    int arr[6]  = {1, 2, 3, 4, 5, 6};
    int length = sizeof(arr) / sizeof(arr[0]);
    int arrSum = sum(arr, length);
    printf("%d\n", arrSum);
    getchar();
    return 0;
}
int sum(const int arr[], int length)
{
    int i;
    // 变量名不要和函数名一样并初始化一个值 否则编译后的结果可能并不是你想要的
    int arrSum = 0;
    for (i = 0; i < length; ++i)
    {
        arrSum += arr[i];
    }
    return arrSum;
}

// 数组

#include <stdio.h>

#define MONTHS 12;

int main(void)

{

int a[6];

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

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

int d[6] = {1, 2, 3};

// 只读数组，必须在声明时赋值

const int e[2] = {1, 2};

// 输出 24 and 24 and 6

printf("%d and %d and %d\n", sizeof(a), sizeof(b), sizeof(b) / sizeof(b[0]));

// 计算数组的长度

int size = sizeof(b) / sizeof(b[0]);

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

{

// a会取内存中的脏值，b、c正常，d的后3位会默认为0

printf("a=%-15d and b=%-15d and c=%-15d and d=%-15d\n", a[i], b[i], c[i], d[i]);

}

// 可以使用[index]来为指定的元素赋值

int days[MONTHS] = {31, 28, [4] = 31, 30, 31, [1] = 29};

getchar();

return 0;

}

// 错误的数组赋值

#include <stdio.h>

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

{

int arr1[4];

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

//以下三种赋值方式都是错误的

arr1 = arr2;

arr1[4] = arr2[4];

//花括号赋值只能用于初始化的时候

arr1[4] = {1, 2, 3, 4};

return 0;

}

// 数组与指针

#include <stdio.h>

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

{

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

int rs;

rs = arr == &arr[0];

printf("%p and %p\n", arr, &arr[0]);

// 输出1(true) 数组名是该数组首元素的地址

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

// 同理 arr+2 == &arr[2] *(arr+2) == arr[2]

getchar();

return 0;

}

// 未初始化的指针赋值

#include <stdio.h>

int main(void)

{

// 以下做法是不对的，把5放到pt所指向的地址，但是地址还没有被初始化

int *pt; //未初始化的指针

*pt = 5;

// 可以这么做

int a;

int *pt;

pt = &a;

*pt = 5;

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

getchar();

return 0;

}

// 比如数组求和，不需要修改数组原值，使用const可防止数组被误修改

#include <stdio.h>

int sum(const int[], int);

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

{

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

int length = sizeof(arr) / sizeof(arr[0]);

int arrSum = sum(arr, length);

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

getchar();

return 0;

}

int sum(const int arr[], int length)

{

int i;

// 变量名不要和函数名一样并初始化一个值否则编译后的结果可能并不是你想要的

int arrSum = 0;

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

{

arrSum += arr[i];

}

return arrSum;

}

基础了解(四)

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

// getchar() putchar()
#include <stdio.h>
int main(int argc, char const *argv[])
{
    char a, b;
    int c, d, e;
    // getchar()和scanf("%c")效果相同，但更快更简洁 部分区别：1.返回值不同，scanf()返回的是字符数 2.scanf()不读取空格、制表符、换行符
    a = getchar();
    c = scanf("%c", &b);
    // putchar()和printf("%c")效果相同，但更快更简洁 部分区别：返回值不同，printf()返回的是字符数
    // 输入ab，输出ab1 -- 97 -- 1
    d = putchar(a);
    e = printf("%c", b);
    printf("%d -- %d -- %d", c, d, e);

    getchar();
    getchar();
    return 0;
}

// 字符函数使用
#include <stdio.h>
// 一系列分析字符的函数 默认在/usr/include中 用sublime打开就可以代码提示了 F12可查看函数参数
#include <ctype.h>
int main(int argc, char const *argv[])
{
    char ch;
    while((ch = getchar()) != '\n')
    {
        // 判断ch是否是字母
        if(isalpha(ch))
        {
            putchar(ch + 1);
        }
        else
        {
            putchar(ch);
        }
    }
    // 打印换行字符
    putchar(ch);
    getchar();
    return 0;
}

// EOF(文件结束符)包含在stdio.h中
#include <stdio.h>
int main(void)
{
    // ./main.exe < input.data >> out.log
    // 会一直读input.data文件，写入out.log
    char c;
    while((c=getchar()) != EOF) {
        putchar(c);
    }
    return 0;
}

// EOF getc()
#include <stdio.h>
// 为了使用exit()方法
#include <stdlib.h>
int main(void)
{
    char c;
    char filename[50];
    FILE *fp;
    printf("please key a filename:");
    scanf("%s", filename);
    fp = fopen(filename, "r");
    if (!fp)
    {
        printf("filename not exists");
        getchar();
        getchar();
        exit(1);
    }
    while( (c = getc(fp)) != EOF)
    {
        putchar(c);
    }
    printf("\nok");
    getchar();
    getchar();
    return 0;
}

// getchar()会读取空格、制表符、换行符
#include <stdio.h>
void display(char cr, int lines, int width);
int main(int argc, char const *argv[])
{
    char ch;
    int rows, cols;
    printf("please key a char and two int \n");
    while( (ch = getchar()) != '\n' )
    {
        // 输入两个数字，正常的返回值是2，反之退出
        if( scanf("%d %d", &rows, &cols) != 2)
        {
            break;
        }
        display(ch, rows, cols);
        // 过滤掉输入1个字符、2个数字后的回车，否则外层循环会读取之，然后直接退出循环
        while(getchar() != '\n')
        {
            continue;
        }
        printf("key another char and two int \n");
        printf("key a newline to quit \n");
    }
    printf("BYE\n");
    return 0;
}
void display(char cr, int lines, int width)
{
    int row, col;
    for (row = 1; row <= lines; row++)
    {
        for(col = 1; col <= width; col++)
        {
            putchar(cr);
        }
        putchar('\n');
    }
}

// & * 符号的使用
#include <stdio.h>
void changeNum(int * a, int * b);
int main(void)
{
    // a=2 b=&a(将a的地址赋值给b或称将b指向a的地址) c=*b(将b指针指向的值赋值给c)
    int a=13, b= 14;
    int * d; //d是指向一个整数变量的指针
    char *f; //f是指向一个字符变量的指针 *和变量之间的空格是可选的，其他类型同理
    printf("a=%d and b=%d\n", a, b);
    changeNum(&a, &b);
    printf("now a=%d and b=%d\n", a, b);
    getchar();
    return 0;
}
void changeNum(int * a, int * b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

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

// getchar() putchar()

#include <stdio.h>

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

{

char a, b;

int c, d, e;

// getchar()和scanf("%c")效果相同，但更快更简洁部分区别：1.返回值不同，scanf()返回的是字符数 2.scanf()不读取空格、制表符、换行符

a = getchar();

c = scanf("%c", &b);

// putchar()和printf("%c")效果相同，但更快更简洁部分区别：返回值不同，printf()返回的是字符数

// 输入ab，输出ab1 -- 97 -- 1

d = putchar(a);

e = printf("%c", b);

printf("%d -- %d -- %d", c, d, e);

getchar();

return 0;

}

// 字符函数使用

#include <stdio.h>

// 一系列分析字符的函数默认在/usr/include中用sublime打开就可以代码提示了 F12可查看函数参数

#include <ctype.h>

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

{

char ch;

while((ch = getchar()) != '\n')

{

// 判断ch是否是字母

if(isalpha(ch))

{

putchar(ch + 1);

}

else

{

putchar(ch);

}

// 打印换行字符

putchar(ch);

getchar();

return 0;

}

// EOF(文件结束符)包含在stdio.h中

#include <stdio.h>

int main(void)

{

// ./main.exe < input.data >> out.log

// 会一直读input.data文件，写入out.log

char c;

while((c=getchar()) != EOF) {

putchar(c);

}

return 0;

}

// EOF getc()

#include <stdio.h>

// 为了使用exit()方法

#include <stdlib.h>

int main(void)

{

char c;

char filename[50];

FILE *fp;

printf("please key a filename:");

scanf("%s", filename);

fp = fopen(filename, "r");

if (!fp)

{

printf("filename not exists");

getchar();

exit(1);

}

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

{

putchar(c);

}

printf("\nok");

getchar();

return 0;

}

// getchar()会读取空格、制表符、换行符

#include <stdio.h>

void display(char cr, int lines, int width);

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

{

char ch;

int rows, cols;

printf("please key a char and two int \n");

while( (ch = getchar()) != '\n' )

{

// 输入两个数字，正常的返回值是2，反之退出

if( scanf("%d %d", &rows, &cols) != 2)

{

break;

}

display(ch, rows, cols);

// 过滤掉输入1个字符、2个数字后的回车，否则外层循环会读取之，然后直接退出循环

while(getchar() != '\n')

{

continue;

}

printf("key another char and two int \n");

printf("key a newline to quit \n");

}

printf("BYE\n");

return 0;

}

void display(char cr, int lines, int width)

{

int row, col;

for (row = 1; row <= lines; row++)

{

for(col = 1; col <= width; col++)

{

putchar(cr);

}

putchar('\n');

}

// & * 符号的使用

#include <stdio.h>

void changeNum(int * a, int * b);

int main(void)

{

// a=2 b=&a(将a的地址赋值给b或称将b指向a的地址) c=*b(将b指针指向的值赋值给c)

int a=13, b= 14;

int * d; //d是指向一个整数变量的指针

char *f; //f是指向一个字符变量的指针 *和变量之间的空格是可选的，其他类型同理

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

changeNum(&a, &b);

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

getchar();

return 0;

}

void changeNum(int * a, int * b)

{

int tmp;

tmp = *a;

*a = *b;

*b = tmp;

}

基础了解(三)

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

//typedef别名 (type)强制转换
#include <stdio.h>
int main(int argc, char const *argv[])
{
    //使real成为double的别名
    typedef double real;
    real xiaoshu = 3.1415;
    printf("%f\n", xiaoshu);

    int num1 = 1.6 + 1.7;
    // 强制转换
    int num2 = (int)1.6 + (int)1.7;
    printf("%d and %d\n", num1, num2);

    getchar();
    return 0;
}

// while结合scanf
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num;
    printf("please key a num\n");
    // 如果输入非整型scanf返回值!=1，退出循环
    while( scanf("%d", &num) == 1 )
    {
        printf("your key num = %d\n", num);
        printf("please key a num\n");
    }
    getchar();
    return 0;
}

// 浮点数比较，需要使用math.h中的fabs函数
#include <stdio.h>
#include <math.h>
int main(int argc, char const *argv[])
{
    double a = 3.1;
    double b = 3.2;
    // 浮点数不能用==比较，舍入误差可能造成两个逻辑上应该相等的数不相等
    // 这个判断会输出neq
    if (a * b == 9.92)
    {
        printf("eq\n");
    }
    else
    {
        printf("neq\n");
    }

    // 可以使用fabs函数进行浮点数比较
    // 这个判断会输出eq
    if (fabs(a * b - 9.92) < 0.0001)
    {
        printf("eq\n");
    }
    else
    {
        printf("neq\n");
    }
    getchar();
    return 0;
}

// for循环中可以使用char类型自增
#include <stdio.h>
int main(int argc, char const *argv[])
{
    char c;
    for (c = 'a'; c <= 'z'; ++c)
    {
        printf("the ascii value for %c is %d\n", c, c);
    }
    getchar();
    return 0;
}

// please key a num会被输出一次，当输入13或非int时，退出循环
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num, status;
    for (printf("please key a num\n"); num != 13;)
    {
        status = scanf("%d", &num);
        if (status != 1)
        {
            break;
        }
        printf("please key a num again\n");
    }
    printf("haha 13 and not int can be out");
    getchar();
    getchar();
    return 0;
}

// ,的使用
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // ,可以使表达式从左到右执行
    int a,b;
    a = 13,14;
    b = (13,14);
    // 输出 a=13 and b=14
    printf("a=%d and b=%d\n", a, b);

    const int FIRST_OZ = 37;
    const int NEXT_OZ = 23;
    int ounces, cost;
    printf("ounces cost\n");
    // for中也可以用, 第一盎司37$，以后每盎司23$
    // 1 $0.37
    // 2 $0.60
    // 3 $0.83
    for (ounces = 1, cost = FIRST_OZ; ounces <= 3; ounces++, cost += NEXT_OZ)
    {
        printf("%5d $%4.2f\n", ounces, cost / 100.0);
    }

    getchar();
    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

//typedef别名 (type)强制转换

#include <stdio.h>

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

{

//使real成为double的别名

typedef double real;

real xiaoshu = 3.1415;

printf("%f\n", xiaoshu);

int num1 = 1.6 + 1.7;

// 强制转换

int num2 = (int)1.6 + (int)1.7;

printf("%d and %d\n", num1, num2);

getchar();

return 0;

}

// while结合scanf

#include <stdio.h>

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

{

int num;

printf("please key a num\n");

// 如果输入非整型scanf返回值!=1，退出循环

while( scanf("%d", &num) == 1 )

{

printf("your key num = %d\n", num);

printf("please key a num\n");

}

getchar();

return 0;

}

// 浮点数比较，需要使用math.h中的fabs函数

#include <stdio.h>

#include <math.h>

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

{

double a = 3.1;

double b = 3.2;

// 浮点数不能用==比较，舍入误差可能造成两个逻辑上应该相等的数不相等

// 这个判断会输出neq

if (a * b == 9.92)

{

printf("eq\n");

}

else

{

printf("neq\n");

}

// 可以使用fabs函数进行浮点数比较

// 这个判断会输出eq

if (fabs(a * b - 9.92) < 0.0001)

{

printf("eq\n");

}

else

{

printf("neq\n");

}

getchar();

return 0;

}

// for循环中可以使用char类型自增

#include <stdio.h>

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

{

char c;

for (c = 'a'; c <= 'z'; ++c)

{

printf("the ascii value for %c is %d\n", c, c);

}

getchar();

return 0;

}

// please key a num会被输出一次，当输入13或非int时，退出循环

#include <stdio.h>

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

{

int num, status;

for (printf("please key a num\n"); num != 13;)

{

status = scanf("%d", &num);

if (status != 1)

{

break;

}

printf("please key a num again\n");

}

printf("haha 13 and not int can be out");

getchar();

return 0;

}

// ,的使用

#include <stdio.h>

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

{

// ,可以使表达式从左到右执行

int a,b;

a = 13,14;

b = (13,14);

// 输出 a=13 and b=14

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

const int FIRST_OZ = 37;

const int NEXT_OZ = 23;

int ounces, cost;

printf("ounces cost\n");

// for中也可以用, 第一盎司37$，以后每盎司23$

// 1 $0.37

// 2 $0.60

// 3 $0.83

for (ounces = 1, cost = FIRST_OZ; ounces <= 3; ounces++, cost += NEXT_OZ)

{

printf("%5d $%4.2f\n", ounces, cost / 100.0);

}

getchar();

return 0;

}

基础了解(二)printf、scanf的简单使用

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

%a  浮点数、十六进制数字和p-记数法(C99)
%A  浮点数、十六进制数字和P-记数法(C99)
%c  一个字符
%d  有符号十进制整数
%e  浮点数、e-记数法
%E  浮点数、E-记数法
%f  浮点数、十进制记数法
%g  根据数值不同自动选择%f或%e。%e格式在指数小于-4或者大于等于精度时使用
%G  根据数值不同自动选择%f或%E。%E格式在指数小于-4或者大于等于精度时使用
%i  有符号十进制整数(与%d相同)
%o  无符号八进制整数
%p  指针
%s  字符串
%u  无符号十进制整数
%x  使用十六进制数字 0f的无符号十六进制整数
%X  使用十六进制数字 0F的无符号十六进制整数
%%  打印一个百分号

前缀0表示8进制
0x或0X表示16进制
后缀l或L表示long  ll或LL表示long long 

#include <stdio.h>
int main(int argc, char const *argv[])
{
    const int num = 222;
    printf("*%d*\n", num);      //输出*222*
    printf("*%2d*\n", num);     //输出*222*  原样输出(2<3)
    printf("*%10d*\n", num);    //输出*       222*  前面有七个空格(7+3=10)
    printf("*%-10d*\n", num);   //输出*222       *  后面有七个空格(有负号)
    //输出1f 1F 0x1f 16进制 #表示0x开头
    printf("%x %X %#x\n", 31, 31, 31);
    //输出**32** 32**-32** 负号正好占用那个空格                  
    printf("**%d**% d**% d**\n", 32, 32, -32);
    //输出**    6**  006**00006**  006** .3表示前置0撑满长度3 优先级高于前置0填充   
    printf("**%5d**%5.3d**%05d**%05.3d**\n", 6, 6, 6, 6);
    getchar();
    return 0;
}

#include <stdio.h>
int main(int argc, char const *argv[])
{
    const double num = 3852.99;
    printf("*%f*\n", num);          //输出*3852.990000*  默认保留6位小数
    printf("*%e*\n", num);          //输出*3.852990e+03*  科学记数法3.852990*10的3次方
    printf("*%4.2f*\n", num);       //输出*3852.99*  长度为4，保留两位小数
    printf("*%3.1f*\n", num);       //输出*3853.0*  长度为3，小于4，取4，保留一位小数，四舍五入
    printf("*%10.3f*\n", num);      //输出*  3852.990*  长度为10，前置3空格，保留3位小数
    printf("*%10.3e*\n", num);      //输出* 3.853e+03* 保留3位小数，3.853*10的3次方
    printf("*%+4.2f*\n", num);      //输出*+3852.99*  增加正号输出，长度4，保留两位小数
    printf("*%010.2f*\n", num);     //输出*0003852.99*  长度为10，前置3个0，保留两位小数
    getchar();
    return 0;
}

#include <stdio.h>
#define STR "Authentic imitation! "
int main(int argc, char const *argv[])
{
    printf("/%s/\n", STR);          //输出/Authentic imitation! /  默认输出
    printf("/%2s/\n", STR);         //输出/Authentic imitation! /  长度2<STR长度，输出默认输出
    printf("/%24s/\n", STR);        //输出/   Authentic imitation! /  长度24>STR，前置空格填充输出
    printf("/%24.5s/\n", STR);      //输出/                   Authe/  长度24>STR，截取5位，前置空格输出
    printf("/%-24.5s/\n", STR);     //输出/Authe                   /  长度24>STR，截取5位，后置空格输出
    getchar();
    return 0;
}

#include <stdio.h>
int main(int argc, char const *argv[])
{
    unsigned int un = 3000000000;
    short end = 200;
    long big = 65537;
    long long verybig = 12345678908642;
    char test = 'A';
    char bing = '\a';
    //输出 un = 3000000000 and not -1294967296  3000000000超过了int的范围，导致结果溢出
    printf("un = %u and not %d\n", un, un);
    //输出 end = 200 and 200  200在short和int的范围内所有%hd %d都可以
    printf("end = %hd and %d\n", end, end);
    //输出 big = 65537 and not 1  65537超出了short的范围
    printf("big = %ld and not %hd\n", big, big);
    //输出 verybig = 12345678908642 and not 1942899938  12345678908642超出了long的范围
    printf("verybig = %lld and not %ld\n", verybig, verybig);
    //输出test = 65 and A  A的int值是65
    printf("test = %d and %c\n", test, test);
    //没有任何输出 \a是响铃符(\007) 如果设备支持会发出一声"嘀"
    printf("%c",bing);
    getchar();
    return 0;
}

#include <stdio.h>
int main(int argc, char const *argv[])
{
    // * 在printf中的使用
    unsigned width,precision;
    int num = 256;
    double weight = 242.5;
    printf("please key width\n");
    scanf("%d", &width);
    //*会匹配width的值为num的长度
    printf("the num is %*d:\n", width, num);
    printf("please key width and precision\n");
    scanf("%d %d", &width, &precision);
    //*会依次匹配width、precision为weight的长度和精度
    printf("weight= %*.*f\n", width, precision, weight);
    getchar();
    return 0;
}

#include <stdio.h>
int main(int argc, char const *argv[])
{
    // * 在scanf中的使用
    int num;
    printf("please key three num\n");
    // 2个*可以过滤掉用户输入的前2个数字，只讲第3个数字赋值给num
    scanf("%*d %*d %d", &num);
    printf("the last num is %d\n", num);
    getchar();
    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

%a 浮点数、十六进制数字和p-记数法(C99)

%A 浮点数、十六进制数字和P-记数法(C99)

%c 一个字符

%d 有符号十进制整数

%e 浮点数、e-记数法

%E 浮点数、E-记数法

%f 浮点数、十进制记数法

%g 根据数值不同自动选择%f或%e。%e格式在指数小于-4或者大于等于精度时使用

%G 根据数值不同自动选择%f或%E。%E格式在指数小于-4或者大于等于精度时使用

%i 有符号十进制整数(与%d相同)

%o 无符号八进制整数

%p 指针

%s 字符串

%u 无符号十进制整数

%x 使用十六进制数字 0f的无符号十六进制整数

%X 使用十六进制数字 0F的无符号十六进制整数

%% 打印一个百分号

前缀0表示8进制

0x或0X表示16进制

后缀l或L表示long ll或LL表示long long

#include <stdio.h>

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

{

const int num = 222;

printf("*%d*\n", num); //输出*222*

printf("*%2d*\n", num); //输出*222* 原样输出(2<3)

printf("*%10d*\n", num); //输出* 222* 前面有七个空格(7+3=10)

printf("*%-10d*\n", num); //输出*222 * 后面有七个空格(有负号)

//输出1f 1F 0x1f 16进制 #表示0x开头

printf("%x %X %#x\n", 31, 31, 31);

//输出**32** 32**-32** 负号正好占用那个空格

printf("**%d**% d**% d**\n", 32, 32, -32);

//输出** 6** 006**00006** 006** .3表示前置0撑满长度3 优先级高于前置0填充

printf("**%5d**%5.3d**%05d**%05.3d**\n", 6, 6, 6, 6);

getchar();

return 0;

}

#include <stdio.h>

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

{

const double num = 3852.99;

printf("*%f*\n", num); //输出*3852.990000* 默认保留6位小数

printf("*%e*\n", num); //输出*3.852990e+03* 科学记数法3.852990*10的3次方

printf("*%4.2f*\n", num); //输出*3852.99* 长度为4，保留两位小数

printf("*%3.1f*\n", num); //输出*3853.0* 长度为3，小于4，取4，保留一位小数，四舍五入

printf("*%10.3f*\n", num); //输出* 3852.990* 长度为10，前置3空格，保留3位小数

printf("*%10.3e*\n", num); //输出* 3.853e+03* 保留3位小数，3.853*10的3次方

printf("*%+4.2f*\n", num); //输出*+3852.99* 增加正号输出，长度4，保留两位小数

printf("*%010.2f*\n", num); //输出*0003852.99* 长度为10，前置3个0，保留两位小数

getchar();

return 0;

}

#include <stdio.h>

#define STR "Authentic imitation! "

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

{

printf("/%s/\n", STR); //输出/Authentic imitation! / 默认输出

printf("/%2s/\n", STR); //输出/Authentic imitation! / 长度2<STR长度，输出默认输出

printf("/%24s/\n", STR); //输出/ Authentic imitation! / 长度24>STR，前置空格填充输出

printf("/%24.5s/\n", STR); //输出/ Authe/ 长度24>STR，截取5位，前置空格输出

printf("/%-24.5s/\n", STR); //输出/Authe / 长度24>STR，截取5位，后置空格输出

getchar();

return 0;

}

#include <stdio.h>

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

{

unsigned int un = 3000000000;

short end = 200;

long big = 65537;

long long verybig = 12345678908642;

char test = 'A';

char bing = '\a';

//输出 un = 3000000000 and not -1294967296 3000000000超过了int的范围，导致结果溢出

printf("un = %u and not %d\n", un, un);

//输出 end = 200 and 200 200在short和int的范围内所有%hd %d都可以

printf("end = %hd and %d\n", end, end);

//输出 big = 65537 and not 1 65537超出了short的范围

printf("big = %ld and not %hd\n", big, big);

//输出 verybig = 12345678908642 and not 1942899938 12345678908642超出了long的范围

printf("verybig = %lld and not %ld\n", verybig, verybig);

//输出test = 65 and A A的int值是65

printf("test = %d and %c\n", test, test);

//没有任何输出 \a是响铃符(\007) 如果设备支持会发出一声"嘀"

printf("%c",bing);

getchar();

return 0;

}

#include <stdio.h>

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

{

// * 在printf中的使用

unsigned width,precision;

int num = 256;

double weight = 242.5;

printf("please key width\n");

scanf("%d", &width);

//*会匹配width的值为num的长度

printf("the num is %*d:\n", width, num);

printf("please key width and precision\n");

scanf("%d %d", &width, &precision);

//*会依次匹配width、precision为weight的长度和精度

printf("weight= %*.*f\n", width, precision, weight);

getchar();

return 0;

}

#include <stdio.h>

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

{

// * 在scanf中的使用

int num;

printf("please key three num\n");

// 2个*可以过滤掉用户输入的前2个数字，只讲第3个数字赋值给num

scanf("%*d %*d %d", &num);

printf("the last num is %d\n", num);

getchar();

return 0;

}

基础了解(一)

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

// 保留关键字以及以_开头的标识符和标准函数名(如：printf)不能定义为变量名 
auto enum restrict unsigned break extern return void case float short volatile char for signed while const
goto sizeof _Bool continue if static _Complex default inline struct _Imaginary do int switch double long typedef
else register union

// 非打印字符
\a  \b  \f  \n  \r  \t  \v  \\  \'  \"  \?  \0oo  \xhh

// 导入标准io库(头文件) #include导入 <>系统本身有的 stdio.h标准io库 .h头文件(类似于php中的interface)
#include <stdio.h>
// 导入int类型库(头文件) 可以使用 uint32_t int16_t等
#include <inttypes.h>
// 导入整数限制库(头文件)
#include <limits.h> 
// 导入浮点数限制库(头文件)
#include <float.h>
// 导入字符串库(头文件) 可以使用strlen等函数
#include <string.h>
// 导入自定义函数库(头文件) ""自定义的
#include "max.h"
// 定义常量(不要用=赋值 不要用;) 可以是整数、浮点、字符、字符串等
#define PI 3.14
#define STR "length test"
// 声明自定义函数
void log(void);
// 入口函数可以不接收参数
int main(void)
{
    // 可以多个声明
    int a, b;
    // 字符串声明 其实只能放19个字符，因为最后一个是不可见的空格符\0用于让计算机知道字符串在哪来中断
    char c[20];
    // 可以声明并赋值
    int d = 2;
    // 另一种常量声明方法，e为只读的3.14
    const float e = 3.14;
    // 自定义函数如果要在main下方实现，需要在mian上方申明
    log();
    // 自定义函数也可以从外部导入
    a = max(PI, d);
    // 接受用户输入一个整型
    scanf("%d", &b);
    // 引用型输入不需要&符合
    scanf("%s", c);
    // 输出用户输入的整型
    printf("%d %s\n", b, c);
    // 获取int型占多少字节 4
    sizeof(int);
    // 获取d这个整型占多少字节 4
    sizeof(d);
    // 获取c这个字符串占多少字节 20
    sizeof(c);
    // 获取c这个字符串的长度 比如输入test则为4
    strlen(c);
    // 获取STR常量占多少字节(后面有个不可见的空格符\0) 12
    sizeof(STR);
    // 获取STR常量的长度 11
    strlen(STR);
    // 用户输入任意键后继续执行，scanf时用户可能输入回车，所以可以用2个getchar()扛住
    getchar();
    getchar();
    return 0;
}
// 自定义函数实现
void log(void) {
    printf("this is a log..");
}

// 保留关键字以及以_开头的标识符和标准函数名(如：printf)不能定义为变量名

auto enum restrict unsigned break extern return void case float short volatile char for signed while const

goto sizeof _Bool continue if static _Complex default inline struct _Imaginary do int switch double long typedef

else register union

// 非打印字符

\a \b \f \n \r \t \v \\ \' \" \? \0oo \xhh

// 导入标准io库(头文件) #include导入 <>系统本身有的 stdio.h标准io库 .h头文件(类似于php中的interface)

#include <stdio.h>

// 导入int类型库(头文件) 可以使用 uint32_t int16_t等

#include <inttypes.h>

// 导入整数限制库(头文件)

#include <limits.h>

// 导入浮点数限制库(头文件)

#include <float.h>

// 导入字符串库(头文件) 可以使用strlen等函数

#include <string.h>

// 导入自定义函数库(头文件) ""自定义的

#include "max.h"

// 定义常量(不要用=赋值不要用;) 可以是整数、浮点、字符、字符串等

#define PI 3.14

#define STR "length test"

// 声明自定义函数

void log(void);

// 入口函数可以不接收参数

int main(void)

{

// 可以多个声明

int a, b;

// 字符串声明其实只能放19个字符，因为最后一个是不可见的空格符\0用于让计算机知道字符串在哪来中断

char c[20];

// 可以声明并赋值

int d = 2;

// 另一种常量声明方法，e为只读的3.14

const float e = 3.14;

// 自定义函数如果要在main下方实现，需要在mian上方申明

log();

// 自定义函数也可以从外部导入

a = max(PI, d);

// 接受用户输入一个整型

scanf("%d", &b);

// 引用型输入不需要&符合

scanf("%s", c);

// 输出用户输入的整型

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

// 获取int型占多少字节 4

sizeof(int);

// 获取d这个整型占多少字节 4

sizeof(d);

// 获取c这个字符串占多少字节 20

sizeof(c);

// 获取c这个字符串的长度比如输入test则为4

strlen(c);

// 获取STR常量占多少字节(后面有个不可见的空格符\0) 12

sizeof(STR);

// 获取STR常量的长度 11

strlen(STR);

// 用户输入任意键后继续执行，scanf时用户可能输入回车，所以可以用2个getchar()扛住

getchar();

return 0;

}

// 自定义函数实现

void log(void) {

printf("this is a log..");

}

C语言简单了解

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

# 参考php大牛老陈^^的博客：https://wp.iter-cc.com/?p=848
# windows编译
# 下载MinGW：http://sourceforge.net/projects/mingw/
# 下载下来后，双击安装(在线安装，必须联网)
# 设置环境变量 我的电脑->属性->高级->环境变量
# path = D:\MinGW\bin  LIBRARY_PATH = D:\MinGW\lib  C_INCLUDEDE_PATH = D:\MinGW\include
# cmd中输入 gcc -v 或 g++ -v 查看安装是否成功
# sublime text 3中有默认的编译器配置，设置好环境变量后按ctrl + b能快捷编译 ctrl+shift+b 能选择编译并运行
# 安装 ConvertToUTF8 插件，设置 default_encoding_on_create="gbk"可以默认新建和保存为GBK编码
# 在windows环境下编译(代码中包含中文，使用gbk编码) 切记：php编码时改回为UTF-8 default_encoding_on_create=""

# linux编译及简单demo
// main.c 简单输出及argc argv参数
#include <stdio.h>
int main(int argc, char const *argv[])
{
    printf("%s\n", "hello world");
    printf("%d\n", argc);
    int i;
    for (i = 0; i < argc; ++i)
    {
        printf("%s\n", argv[i]);
    }
    return 0;
}

# gcc main.c会编译生成a.out(默认) 可以通过-o指定编译文件名 如：gcc main.c -o main.out
# 执行a.out argv1输出如下
[root@BestLove c]# ./a.out argv1
hello world
2
./a.out
argv1

// main.c 多文件编译
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int maxNum;
    maxNum = max(13, 14);
    printf("%d\n", maxNum);
    return 0;
}

// max.c
int max(int num1, int num2)
{
    if (num1 > num2)
    {
        return num1;
    }
    else
    {
        return num2;
    }
}

# 此时直接gcc main.c会报错 可以执行gcc main.c max.c进行编译
# 以上方法在老版本编译器中会出错
# 或者在 main.c文件第2行增加导入 #include "max.c" 执行gcc main.c
# 以上方法只是将max.c的内容复制到main.c中，文件多的话编译会很慢
# 或者执行gcc -c max.c生成max.o文件 再执行 gcc main.c max.o
// max.h
int max(int num1, int num2);
# 但是对于一些第三方的类或框架，我们只有编译后的文件，没有源码，不知道函数参数、返回值等
# 此时，可以在main.c文件第2行引入.h头文件 #include "max.h" 再执行gcc main.c max.o 

# 编译大型项目时，可编写Makefile文件(缩进必须为tab不能用空格替代，否则会报错)
main.out:max.o main.c
    gcc max.o main.c -o main.out
max.o:max.c
    gcc -c max.c
# 执行 make 编译成功

// main.c 接收输入值
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num;
    printf("请输入你的年龄：");
    // 默认接收键盘输入
    scanf("%d", &num);
    if (num > 100)
    {
        fprintf(stderr, "%s\n", "别乱输。。");
        return 1;
    }
    //printf底层调用的就是fprintf传入stdout
    fprintf(stdout, "%s\n", "ok");
    return 0;
}

# gcc main.c -o scanf.out后 执行./scanf.out < input.data 1>out.log 2>err.log 会改变原来的键盘输入，屏幕输出为input.data文件输入，重定向文件输出

// main.c 写文件
#include <stdio.h>
int main(int argc, char const *argv[])
{
    FILE *outFp = fopen("./output.log", "w+");
    FILE *errFp = fopen("./error.log", "w+");
    int num;
    printf("请输入你的年龄：");
    scanf("%d", &num);
    if (num > 100)
    {
        fprintf(errFp, "%s\n", "别乱输。。");
        fclose(outFp);
        fclose(errFp);
        return 1;
    }

    fprintf(outFp, "%s\n", "ok");
    fclose(outFp);
    fclose(errFp);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

# 参考php大牛老陈^^的博客：https://wp.iter-cc.com/?p=848

# windows编译

# 下载MinGW：http://sourceforge.net/projects/mingw/

# 下载下来后，双击安装(在线安装，必须联网)

# 设置环境变量我的电脑->属性->高级->环境变量

# path = D:\MinGW\bin LIBRARY_PATH = D:\MinGW\lib C_INCLUDEDE_PATH = D:\MinGW\include

# cmd中输入 gcc -v 或 g++ -v 查看安装是否成功

# sublime text 3中有默认的编译器配置，设置好环境变量后按ctrl + b能快捷编译 ctrl+shift+b 能选择编译并运行

# 安装 ConvertToUTF8 插件，设置 default_encoding_on_create="gbk"可以默认新建和保存为GBK编码

# 在windows环境下编译(代码中包含中文，使用gbk编码) 切记：php编码时改回为UTF-8 default_encoding_on_create=""

# linux编译及简单demo

// main.c 简单输出及argc argv参数

#include <stdio.h>

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

{

printf("%s\n", "hello world");

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

int i;

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

{

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

}

return 0;

}

# gcc main.c会编译生成a.out(默认) 可以通过-o指定编译文件名如：gcc main.c -o main.out

# 执行a.out argv1输出如下

[root@BestLove c]# ./a.out argv1

hello world

./a.out

argv1

// main.c 多文件编译

#include <stdio.h>

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

{

int maxNum;

maxNum = max(13, 14);

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

return 0;

}

// max.c

int max(int num1, int num2)

{

if (num1 > num2)

{

return num1;

}

else

{

return num2;

}

# 此时直接gcc main.c会报错可以执行gcc main.c max.c进行编译

# 以上方法在老版本编译器中会出错

# 或者在 main.c文件第2行增加导入 #include "max.c" 执行gcc main.c

# 以上方法只是将max.c的内容复制到main.c中，文件多的话编译会很慢

# 或者执行gcc -c max.c生成max.o文件再执行 gcc main.c max.o

// max.h

int max(int num1, int num2);

# 但是对于一些第三方的类或框架，我们只有编译后的文件，没有源码，不知道函数参数、返回值等

# 此时，可以在main.c文件第2行引入.h头文件 #include "max.h" 再执行gcc main.c max.o

# 编译大型项目时，可编写Makefile文件(缩进必须为tab不能用空格替代，否则会报错)

main.out:max.o main.c

gcc max.o main.c -o main.out

max.o:max.c

gcc -c max.c

# 执行 make 编译成功

// main.c 接收输入值

#include <stdio.h>

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

{

int num;

printf("请输入你的年龄：");

// 默认接收键盘输入

scanf("%d", &num);

if (num > 100)

{

fprintf(stderr, "%s\n", "别乱输。。");

return 1;

}

//printf底层调用的就是fprintf传入stdout

fprintf(stdout, "%s\n", "ok");

return 0;

}

# gcc main.c -o scanf.out后执行./scanf.out < input.data 1>out.log 2>err.log 会改变原来的键盘输入，屏幕输出为input.data文件输入，重定向文件输出

// main.c 写文件

#include <stdio.h>

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

{

FILE *outFp = fopen("./output.log", "w+");

FILE *errFp = fopen("./error.log", "w+");

int num;

printf("请输入你的年龄：");

scanf("%d", &num);

if (num > 100)

{

fprintf(errFp, "%s\n", "别乱输。。");

fclose(outFp);

fclose(errFp);

return 1;

}

fprintf(outFp, "%s\n", "ok");

fclose(outFp);

fclose(errFp);

return 0;

}

唐晓锋–BLOG

This is just a personal note.

作者：BestLove

基础了解(五)

基础了解(四)

基础了解(三)

基础了解(二)printf、scanf的简单使用

基础了解(一)

C语言简单了解