基础了解(六)

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

// 指针地址和指针的值都可以设置为常量
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // 将常量或者非常量的数据的地址赋值给常量指针是合法的
    double rates[5] = {11.11, 22.22, 33.33, 44.44, 55.55};
    const double locked[4] = {0.1, 0.2, 0.3, 0.4, 0.5};
    const double *pc = rates;   //合法
    pc = locked;                //合法
    pc = &rates[3];             //合法
    // 只有非常量数据的地址才能赋值给普通指针
    double rates[5] = {11.11, 22.22, 33.33, 44.44, 55.55};
    const double locked[4] = {0.1, 0.2, 0.3, 0.4, 0.5};
    double *pnc = rates;         //合法
    pnc = locked;                //非法
    pnc = &rates[3];             //合法
    // 以上做法是合理的，否则可以使用指针来修改常量值了 如*pnc=13
    
    // const放在*后面表示指针地址是常量、而不是指针的值是常量
    double rates[5] = {11.11, 22.22, 33.33, 44.44, 55.55};
    double * const pc = rates;  //pc指向数组的开始处
    pc = &rates[2];             //不允许修改指针地址
    *pc = 22.22;                //但是允许修改它的值
    // 将指针地址和指针的值都设置常量
    const double * const pc = rates;
    return 0;
}

// 二维数组与指针(多维数组同理)
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int zippo[4][2] = { {2, 4}, {6, 7}, {1, 3}, {5, 7} };
    printf("zippo=%p zippo+1=%p zippo[0]+2=%p\n", zippo, zippo + 1, zippo[0]+2);
    printf("zippo[0]=%p zippo[0]+1=%p\n", zippo[0], zippo[0] + 1);
    printf("*zippo=%p *zippo+1=%p\n", *zippo, *zippo + 1);
    printf("zippo[0][0]=%d\n", zippo[0][0]);
    printf("*zippo[0]=%d\n", *zippo[0]);
    printf("**zippo=%d\n", **zippo);
    printf("zippo[2][1]=%d\n", zippo[2][1]);
    printf("*(*(zippo+2)+1)=%d\n", *(*(zippo + 2) + 1));
    /* 输出如下
        zippo=0028FF20 zippo+1=0028FF28 zippo[0]+2=0028FF28             //zippo和zippo[0]的指针地址相同，但+1后不同，因为步进不同
        zippo[0]=0028FF20 zippo[0]+1=0028FF24                           //因为第2维的数组长度是2，所以zippo+1和zippo[0]+2的地址相同
        *zippo=0028FF20 *zippo+1=0028FF24                               //对zippo取值其实就是zippo[0]的地址 所以*zippo+1和zippo[0]+1的地址相同
        zippo[0][0]=2                                                   //同理zippo[0][0]==*zippo[0]==**zippo==2
        *zippo[0]=2
        **zippo=2
        zippo[2][1]=3                                                   //同理zippo[2][1]==*(*(zippo+2)+1)==3
        *(*(zippo+2)+1)=3
    */
    getchar();
    return 0;
}

// 数组指针与指针数组
#include <stdio.h>
int main(int argc, char const *argv[])
{
    //pz是指向一个包含2个int值的数组的指针 一定要用小括号
    //因为int * pz[2]表示2个int型指针的数组 "[]"的优先级更高
    int (*pz)[2];
    return 0;
}

// 数组的指针
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int zippo[4][2] = { {2, 4}, {6, 7}, {1, 3}, {5, 7} };
    int (*pz)[2];
    pz = zippo;
    printf("pz=%p pz+1=%p\n", pz, pz + 1);
    printf("pz[0]=%p pz[0]+1=%p\n", pz[0], pz[0] + 1);
    printf("*pz=%p *pz+1=%p\n", *pz, *pz + 1);
    printf("pz[0][0]=%d\n", pz[0][0]);
    printf("*pz[0]=%d\n", *pz[0]);
    printf("**pz=%d\n", **pz);
    printf("pz[2][1]=%d\n", pz[2][1]);
    printf("*(*(pz+2)+1)=%d\n", *(*(pz + 2) + 1));
    getchar();
    /*  输出如下
        pz=0028FF1C pz+1=0028FF24
        pz[0]=0028FF1C pz[0]+1=0028FF20
        *pz=0028FF1C *pz+1=0028FF20
        pz[0][0]=2
        *pz[0]=2
        **pz=2
        pz[2][1]=3
        *(*(pz+2)+1)=3
    */
    return 0;
}

// 指针赋值比数值赋值更严格
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int n = 5;
    double x;
    int *pi = &n;
    double *pd = &x;
    x = n;      //会隐性类型转换
    pd = pi;    //编译报错

    int *pt;
    int (*pa)[3];
    int ar1[2][3];
    int ar2[3][2];
    int **p2;   //指向指针的指针
    pt = &ar1[0][0];    //合法 指向int
    pt = ar1[0];        //合法 指向int
    pt = ar1;           //非法
    pa = ar1;           //合法 指向int[3]
    pa = ar2;           //非法
    p2 = &pt;           //合法 指向int的指针
    *p2 = ar2[0];       //合法 指向int
    p2 = ar2;           //非法
    return 0;
}

// 两层间接以上，非const不允许赋值给const
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int * p1;
    const int * p2;
    const int ** pp2;
    p1 = p2;    //非法，const赋值给非const
    p2 = p1;    //合法，非const赋值给const
    pp2 = &p1;  //非法，两层间接后，非const不允许赋值给const
    //原因如下
    const int **pp2;
    int *p1;
    const int n = 13;
    pp2 = &p1;  //不允许，我们假设其是合法的
    *pp2 = &n;  //合法，都是const，但同时会使p1指向n
    *p1 = 10;   //合法，但这样会改变const n的值
    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

// 指针地址和指针的值都可以设置为常量

#include <stdio.h>

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

{

// 将常量或者非常量的数据的地址赋值给常量指针是合法的

double rates[5] = {11.11, 22.22, 33.33, 44.44, 55.55};

const double locked[4] = {0.1, 0.2, 0.3, 0.4, 0.5};

const double *pc = rates; //合法

pc = locked; //合法

pc = &rates[3]; //合法

// 只有非常量数据的地址才能赋值给普通指针

double rates[5] = {11.11, 22.22, 33.33, 44.44, 55.55};

const double locked[4] = {0.1, 0.2, 0.3, 0.4, 0.5};

double *pnc = rates; //合法

pnc = locked; //非法

pnc = &rates[3]; //合法

// 以上做法是合理的，否则可以使用指针来修改常量值了如*pnc=13

// const放在*后面表示指针地址是常量、而不是指针的值是常量

double rates[5] = {11.11, 22.22, 33.33, 44.44, 55.55};

double * const pc = rates; //pc指向数组的开始处

pc = &rates[2]; //不允许修改指针地址

*pc = 22.22; //但是允许修改它的值

// 将指针地址和指针的值都设置常量

const double * const pc = rates;

return 0;

}

// 二维数组与指针(多维数组同理)

#include <stdio.h>

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

{

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

printf("zippo=%p zippo+1=%p zippo[0]+2=%p\n", zippo, zippo + 1, zippo[0]+2);

printf("zippo[0]=%p zippo[0]+1=%p\n", zippo[0], zippo[0] + 1);

printf("*zippo=%p *zippo+1=%p\n", *zippo, *zippo + 1);

printf("zippo[0][0]=%d\n", zippo[0][0]);

printf("*zippo[0]=%d\n", *zippo[0]);

printf("**zippo=%d\n", **zippo);

printf("zippo[2][1]=%d\n", zippo[2][1]);

printf("*(*(zippo+2)+1)=%d\n", *(*(zippo + 2) + 1));

/* 输出如下

zippo=0028FF20 zippo+1=0028FF28 zippo[0]+2=0028FF28 //zippo和zippo[0]的指针地址相同，但+1后不同，因为步进不同

zippo[0]=0028FF20 zippo[0]+1=0028FF24 //因为第2维的数组长度是2，所以zippo+1和zippo[0]+2的地址相同

*zippo=0028FF20 *zippo+1=0028FF24 //对zippo取值其实就是zippo[0]的地址所以*zippo+1和zippo[0]+1的地址相同

zippo[0][0]=2 //同理zippo[0][0]==*zippo[0]==**zippo==2

*zippo[0]=2

**zippo=2

zippo[2][1]=3 //同理zippo[2][1]==*(*(zippo+2)+1)==3

*(*(zippo+2)+1)=3

getchar();

return 0;

}

// 数组指针与指针数组

#include <stdio.h>

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

{

//pz是指向一个包含2个int值的数组的指针一定要用小括号

//因为int * pz[2]表示2个int型指针的数组 "[]"的优先级更高

int (*pz)[2];

return 0;

}

// 数组的指针

#include <stdio.h>

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

{

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

int (*pz)[2];

pz = zippo;

printf("pz=%p pz+1=%p\n", pz, pz + 1);

printf("pz[0]=%p pz[0]+1=%p\n", pz[0], pz[0] + 1);

printf("*pz=%p *pz+1=%p\n", *pz, *pz + 1);

printf("pz[0][0]=%d\n", pz[0][0]);

printf("*pz[0]=%d\n", *pz[0]);

printf("**pz=%d\n", **pz);

printf("pz[2][1]=%d\n", pz[2][1]);

printf("*(*(pz+2)+1)=%d\n", *(*(pz + 2) + 1));

getchar();

/* 输出如下

pz=0028FF1C pz+1=0028FF24

pz[0]=0028FF1C pz[0]+1=0028FF20

*pz=0028FF1C *pz+1=0028FF20

pz[0][0]=2

*pz[0]=2

**pz=2

pz[2][1]=3

*(*(pz+2)+1)=3

return 0;

}

// 指针赋值比数值赋值更严格

#include <stdio.h>

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

{

int n = 5;

double x;

int *pi = &n;

double *pd = &x;

x = n; //会隐性类型转换

pd = pi; //编译报错

int *pt;

int (*pa)[3];

int ar1[2][3];

int ar2[3][2];

int **p2; //指向指针的指针

pt = &ar1[0][0]; //合法指向int

pt = ar1[0]; //合法指向int

pt = ar1; //非法

pa = ar1; //合法指向int[3]

pa = ar2; //非法

p2 = &pt; //合法指向int的指针

*p2 = ar2[0]; //合法指向int

p2 = ar2; //非法

return 0;

}

// 两层间接以上，非const不允许赋值给const

#include <stdio.h>

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

{

int * p1;

const int * p2;

const int ** pp2;

p1 = p2; //非法，const赋值给非const

p2 = p1; //合法，非const赋值给const

pp2 = &p1; //非法，两层间接后，非const不允许赋值给const

//原因如下

const int **pp2;

int *p1;

const int n = 13;

pp2 = &p1; //不允许，我们假设其是合法的

*pp2 = &n; //合法，都是const，但同时会使p1指向n

*p1 = 10; //合法，但这样会改变const n的值

return 0;

}

基础了解(五)

在 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..");

}

唐晓锋–BLOG

This is just a personal note.

分类：c

基础了解(六)

基础了解(五)

基础了解(四)

基础了解(三)

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

基础了解(一)