基础了解(九)

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

// 字符串转数字等
#include <stdio.h>
// atoi()字符串转INT atof()字符串转浮点 atol()字符转LONG型
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    char a[11] = "abcdef";
    char c[11] = "123";
    int b, d;
    b = atoi(a);
    d = atoi(c);
    // 输出0 123
    printf("%d  %d\n", b, d);
    getchar();
    return 0;
}

// strtol() strtoul()无符号long strtod()等是atoxxx的复杂版本
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    char number[30];
    char * end;
    long value;
    puts("Enter a number (empty line to quit):");
    while(gets(number) && number[0] != '\0')
    {
        value = strtol(number, &end, 10);
        printf("value:%ld stopped at %s (%d)\n", value, end, *end);
        value = strtol(number, &end, 2);
        printf("value:%ld stopped at %s (%d)\n", value, end, *end);
        puts("next number:");
    }
    puts("Bye!");
    /*
        Enter a number (empty line to quit):
        10      //输入10 当基数(进制)为10时value=10 为2时 value=2 end为空 *end为0
        value:10 stopped at  (0)
        value:2 stopped at  (0)
        next number:
        10a     //输入10a end为a *end为97(ANSI编码)
        value:10 stopped at a (97)
        value:2 stopped at a (97)
     */
    getchar();
    return 0;
}

// gcc -std=c99 支持C99特性
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // for中直接定义i 需要C99支持
    for (int i = 0; i < 3; ++i)
    {
        printf("%d\n", i);
    }
    getchar();
    return 0;
}

// 存储类、链接、内存管理
// auto extern static register const volatile restricted
// rand() srand() time() malloc() calloc() free()
#include <stdio.h>
int outFileCanRead = 13;    //文件作用域，外部链接external linkage
// 这里的static表明链接类型，并非存储时期。所有的文件作用域变量都具有静态存储时期
static int thisFileCanRead = 13;    //文件作用域，内部链接internal linkage
int main(int argc, char const *argv[])
{
    static int notAuto = 13;    //静态存储时期
    int mainCanRead = 13;       //代码段作用域，空链接no linkage 自动存储时期
    //函数作用域 function scope go to语句所使用的标签，空链接
    //C使用作用域、链接和存储时期来定义5种存储类
/*
存储类                 时期      作用域         链接      声明方式
自动                   自动      代码块         空        代码块内
寄存器                 自动      代码块         空        代码块内，使用关键字register
具有外部链接的静态     静态      文件           外部      所有函数之外
具有内部链接的静态     静态      文件           内部      所有函数之外，使用关键字static
空链接的静态           静态      代码块         空        代码块内，使用关键字static
*/
    printf("%d %d\n", notAuto, mainCanRead);
    getchar();
    return 0;
}

// 字符串转数字等

#include <stdio.h>

// atoi()字符串转INT atof()字符串转浮点 atol()字符转LONG型

#include <stdlib.h>

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

{

char a[11] = "abcdef";

char c[11] = "123";

int b, d;

b = atoi(a);

d = atoi(c);

// 输出0 123

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

getchar();

return 0;

}

// strtol() strtoul()无符号long strtod()等是atoxxx的复杂版本

#include <stdio.h>

#include <stdlib.h>

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

{

char number[30];

char * end;

long value;

puts("Enter a number (empty line to quit):");

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

{

value = strtol(number, &end, 10);

printf("value:%ld stopped at %s (%d)\n", value, end, *end);

value = strtol(number, &end, 2);

printf("value:%ld stopped at %s (%d)\n", value, end, *end);

puts("next number:");

}

puts("Bye!");

Enter a number (empty line to quit):

10 //输入10 当基数(进制)为10时value=10 为2时 value=2 end为空 *end为0

value:10 stopped at (0)

value:2 stopped at (0)

next number:

10a //输入10a end为a *end为97(ANSI编码)

value:10 stopped at a (97)

value:2 stopped at a (97)

getchar();

return 0;

}

// gcc -std=c99 支持C99特性

#include <stdio.h>

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

{

// for中直接定义i 需要C99支持

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

{

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

}

getchar();

return 0;

}

// 存储类、链接、内存管理

// auto extern static register const volatile restricted

// rand() srand() time() malloc() calloc() free()

#include <stdio.h>

int outFileCanRead = 13; //文件作用域，外部链接external linkage

// 这里的static表明链接类型，并非存储时期。所有的文件作用域变量都具有静态存储时期

static int thisFileCanRead = 13; //文件作用域，内部链接internal linkage

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

{

static int notAuto = 13; //静态存储时期

int mainCanRead = 13; //代码段作用域，空链接no linkage 自动存储时期

//函数作用域 function scope go to语句所使用的标签，空链接

//C使用作用域、链接和存储时期来定义5种存储类

存储类时期作用域链接声明方式

自动自动代码块空代码块内

寄存器自动代码块空代码块内，使用关键字register

具有外部链接的静态静态文件外部所有函数之外

具有内部链接的静态静态文件内部所有函数之外，使用关键字static

空链接的静态静态代码块空代码块内，使用关键字static

printf("%d %d\n", notAuto, mainCanRead);

getchar();

return 0;

}

基础了解(八)

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

// 字符串数组 字符串指针
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // 以下两种定义差别不大，区别在于heart是地址常量，head是一个变量
    char heart[] = "I love Tillie!";
    char *head = "I love Millie!";
    // 变量可以++，常量不行
    while(*(head) != '\0') {
        putchar(*(head++));
    }
    // 允许 现在head指向数组heart，但是不会使I love Millie!字符串消失
    // 除非已在别处保存了I love Millie! 否则这个字符串就无法访问了
    head = heart;
    // 不允许 这种情况类似 3=x; 把变量赋值给常量
    heart = head;
    getchar();
    return 0;
}

// gets() puts() 以及读取用户输入要设置长度
#include <stdio.h>
#define LEN 81
int main(int argc, char const *argv[])
{
    // 记住一定要定义长度(分配内存空间)，否则读入的name可能会覆盖程序中的数据和代码
    char name[LEN];
    char * returnVal;
    puts("what's your name");
    // gets() puts() 跟scanf("%s") printf("%s")效果类似
    returnVal = gets(name);
    puts(name);
    // gets()返回用户输入字符串的地址，puts(returnVal)和puts(name)输出一样
    puts(returnVal);
    printf("what's your name\n");
    char name1[LEN];
    scanf("%s", name1);
    printf("%s\n", name1);
    getchar();
    getchar();
    return 0;
}

// gets()不会检查预留储存区的长度
// 如果单行超过19个字符，会溢出到相邻内存
#include <stdio.h>
int main(int argc, char const *argv[])
{
    char name[20];
    // 如果gets出错返回一个空指针NULL
    // 空指针是一个地址，空字符是一个char类型的数据对象
    // 数值上两者都可以用0表示，但它们的概念不同
    // 下面循环方式既可以检查是否读到文件结尾，又可以读取一个值
    // 比while((ch=getchar())!=EOF)方便
    while(gets(name) != NULL)
    {
        puts(name);
    }
    return 0;
}

// fgets()在键盘输入中的使用 gets()存在溢出问题，所以fgets()更安全
#include <stdio.h>
#define MAX 21
int main(int argc, char const *argv[])
{
    char name[MAX];
    char * ptr;
    puts("Hi what's your name");
    // fgets()可以避免gets()的数据溢出问题
    // 但是它是为文件I/O而设计的，读取键盘输入时没有gets()方便，需要在第3个参数键入stdin
    ptr = fgets(name, MAX, stdin);
    puts(name);
    puts(ptr);
    return 0;
}

// strcat(str1,str2)合并字符串
// 如果第一个字符串的长度不够，合并完之后的字符串就会溢出到相邻的存储单元
// strncat(str1,str2,13) 13为允许合并的最大长度
#include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    char name[10];
    char info[]=" I'm your father";
    puts("please key your name");
    gets(name);
    //将第2个字符串的一份拷贝添加到第一个字符串结尾
    strcat(name, info);
    puts(name);
    puts(info);
    getchar();
    return 0;
}

// strcmp(str1,str2)比较字符串大小
// strncmp(str1,str2,5)比较字符串前5个字符大小
// sprintf(formal,"%s...",str...)和printf()类似 一个接收到formal变量 一个输出 

// str1=str2只是指针赋值，如果需要复制值可以使用strcpy(str1,str2)
// 同样strcpy也存在溢出问题 可以使用strncpy(str1,str2,maxCopyLen)
#include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    char test[20];
    int x;
    x = 13;                         //数值赋值
    strcpy(test, "hello world");    //字符串赋值
    test = "hello world";           //语法错误
    strcpy(test+6, "fuck");         //从第6个字符开始 此时test=hello fuck
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

// 字符串数组字符串指针

#include <stdio.h>

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

{

// 以下两种定义差别不大，区别在于heart是地址常量，head是一个变量

char heart[] = "I love Tillie!";

char *head = "I love Millie!";

// 变量可以++，常量不行

while(*(head) != '\0') {

putchar(*(head++));

}

// 允许现在head指向数组heart，但是不会使I love Millie!字符串消失

// 除非已在别处保存了I love Millie! 否则这个字符串就无法访问了

head = heart;

// 不允许这种情况类似 3=x; 把变量赋值给常量

heart = head;

getchar();

return 0;

}

// gets() puts() 以及读取用户输入要设置长度

#include <stdio.h>

#define LEN 81

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

{

// 记住一定要定义长度(分配内存空间)，否则读入的name可能会覆盖程序中的数据和代码

char name[LEN];

char * returnVal;

puts("what's your name");

// gets() puts() 跟scanf("%s") printf("%s")效果类似

returnVal = gets(name);

puts(name);

// gets()返回用户输入字符串的地址，puts(returnVal)和puts(name)输出一样

puts(returnVal);

printf("what's your name\n");

char name1[LEN];

scanf("%s", name1);

printf("%s\n", name1);

getchar();

return 0;

}

// gets()不会检查预留储存区的长度

// 如果单行超过19个字符，会溢出到相邻内存

#include <stdio.h>

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

{

char name[20];

// 如果gets出错返回一个空指针NULL

// 空指针是一个地址，空字符是一个char类型的数据对象

// 数值上两者都可以用0表示，但它们的概念不同

// 下面循环方式既可以检查是否读到文件结尾，又可以读取一个值

// 比while((ch=getchar())!=EOF)方便

while(gets(name) != NULL)

{

puts(name);

}

return 0;

}

// fgets()在键盘输入中的使用 gets()存在溢出问题，所以fgets()更安全

#include <stdio.h>

#define MAX 21

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

{

char name[MAX];

char * ptr;

puts("Hi what's your name");

// fgets()可以避免gets()的数据溢出问题

// 但是它是为文件I/O而设计的，读取键盘输入时没有gets()方便，需要在第3个参数键入stdin

ptr = fgets(name, MAX, stdin);

puts(name);

puts(ptr);

return 0;

}

// strcat(str1,str2)合并字符串

// 如果第一个字符串的长度不够，合并完之后的字符串就会溢出到相邻的存储单元

// strncat(str1,str2,13) 13为允许合并的最大长度

#include <stdio.h>

#include <string.h>

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

{

char name[10];

char info[]=" I'm your father";

puts("please key your name");

gets(name);

//将第2个字符串的一份拷贝添加到第一个字符串结尾

strcat(name, info);

puts(name);

puts(info);

getchar();

return 0;

}

// strcmp(str1,str2)比较字符串大小

// strncmp(str1,str2,5)比较字符串前5个字符大小

// sprintf(formal,"%s...",str...)和printf()类似一个接收到formal变量一个输出

// str1=str2只是指针赋值，如果需要复制值可以使用strcpy(str1,str2)

// 同样strcpy也存在溢出问题可以使用strncpy(str1,str2,maxCopyLen)

#include <stdio.h>

#include <string.h>

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

{

char test[20];

int x;

x = 13; //数值赋值

strcpy(test, "hello world"); //字符串赋值

test = "hello world"; //语法错误

strcpy(test+6, "fuck"); //从第6个字符开始此时test=hello fuck

return 0;

}

基础了解(七)

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

// 函数指针参数的多种写法(非变长数组，列不能变，行能变)
#include <stdio.h>
void somefunction(int (*pt)[4]);
void somefunction(int pt[][4]);     //如果pt是函数参量，也可以这么写 "[]"表示pt是一个指针
void somefunction(int pt[3][4]);    //合法申明，但是3会被忽略
void somefunction(int [][4]);       //可以省略名称
//以下三种函数声明方式相同，typedef声明较为繁琐，不建议使用
typedef int arr4[4];
typedef arr4 arr3x4[3];
int sum(arr3x4 ar, int rows);
int sum(int ar[3][4], int rows);
int sum(int ar[][4], int rows);
int main(int argc, char const *argv[])
{
    return 0;
}

// 可变长数组，需要较新编译器
#include <stdio.h>
//row和col必须写在arr[row][col]之前
//或者可以这么写int sum(int, int, arr[*][*])
int sum(int row, int col, int arr[row][col]);
int main(int argc, char const *argv[])
{
    int total;
    int arr[2][2] = { {1,2}, {3,4} };
    total = sum(2, 2, arr);
    printf("%d\n", total);
    getchar();
    return 0;
}
int sum(int row, int col, int arr[row][col])
{
    int i,j;
    int total = 0;
    for (i = 0; i < row; ++i)
    {
        for (j = 0; j < col; ++j)
        {
            total += arr[i][j];
        }
    }
    return total;
}

// 匿名数组，复合文字
#include <stdio.h>
int main(int argc, char const *argv[])
{
    // 5是int类型文字，9.9是double类型文字
    // 匿名数组 是一种复合文字 可以省略数组长度(int[])={1,2};
    (int [2]) = {1,2};
    // 匿名数组没有名称，可以使用指针保存其位置
    int *pt1;
    pt1 = (int [2]) = {1,2};
    // 也可以作为函数参数
    int total;
    total = sum((int[]){1,2,3}, 3);
    return 0;
}

// 函数指针参数的多种写法(非变长数组，列不能变，行能变)

#include <stdio.h>

void somefunction(int (*pt)[4]);

void somefunction(int pt[][4]); //如果pt是函数参量，也可以这么写 "[]"表示pt是一个指针

void somefunction(int pt[3][4]); //合法申明，但是3会被忽略

void somefunction(int [][4]); //可以省略名称

//以下三种函数声明方式相同，typedef声明较为繁琐，不建议使用

typedef int arr4[4];

typedef arr4 arr3x4[3];

int sum(arr3x4 ar, int rows);

int sum(int ar[3][4], int rows);

int sum(int ar[][4], int rows);

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

{

return 0;

}

// 可变长数组，需要较新编译器

#include <stdio.h>

//row和col必须写在arr[row][col]之前

//或者可以这么写int sum(int, int, arr[*][*])

int sum(int row, int col, int arr[row][col]);

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

{

int total;

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

total = sum(2, 2, arr);

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

getchar();

return 0;

}

int sum(int row, int col, int arr[row][col])

{

int i,j;

int total = 0;

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

{

for (j = 0; j < col; ++j)

{

total += arr[i][j];

}

return total;

}

// 匿名数组，复合文字

#include <stdio.h>

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

{

// 5是int类型文字，9.9是double类型文字

// 匿名数组是一种复合文字可以省略数组长度(int[])={1,2};

(int [2]) = {1,2};

// 匿名数组没有名称，可以使用指针保存其位置

int *pt1;

pt1 = (int [2]) = {1,2};

// 也可以作为函数参数

int total;

total = sum((int[]){1,2,3}, 3);

return 0;

}

基础了解(六)

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

}

唐晓锋–BLOG

This is just a personal note.

月份：2016年6月

基础了解(九)

基础了解(八)

基础了解(七)

基础了解(六)

基础了解(五)