当前位置: 开发笔记 > 编程语言 > 正文

每天一得数组

作者：akun | 来源：互联网 | 2023-06-06 17:54

数组定义的时候，【】内部一定是常量，使用的时候就可以是变量。数组名是一个常量，它的值是第一个数组变量的地址。数组内部是同一类型，连续的。数组个数不足时，默认补零。数组成员的个数：s

数组定义的时候，【】内部一定是常量，使用的时候就可以是变量。

数组名是一个常量，它的值是第一个数组变量的地址。

数组内部是同一类型，连续的。

数组个数不足时，默认补零。

数组成员的个数：sizeof(数组名) / sizeof(数组第一个元素)

示例：

#include 

int main()
{
   int a[]={23,56,98,1,12};
    int i;
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
        printf("a[%d] = %d \n",i,a[i]);
   
   return 0;
}

a[0] = 23
a[1] = 56
a[2] = 98
a[3] = 1
a[4] = 12

可以任意改变数组的个数：

#include 

int main()
{
   int a[]={23,56};
    int i;
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
        printf("a[%d] = %d \n",i,a[i]);
   
   return 0;
}

a[0] = 23
a[1] = 56

示例2 得出数组最大数：

#include 

int main()
{
   int a[]={23,56,98,104,187,188,786,342,218,436};
    int i,tmp=0;
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
    {
        if(a[i]>tmp)
            tmp = a[i];
    }
    printf("最大的数是： %d \n",tmp);   
   return 0;
}

最大的数是： 786

以上代码是有问题的，假设数组成员都是负数：

#include 

int main()
{
   int a[]={-23,-56,-98,-104,-187,-188,-786,-342,-218,-436};
    int i,tmp=0;
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
    {
        if(a[i]>tmp)
            tmp = a[i];
    }
    printf("最大的数是： %d \n",tmp);   
   return 0;
}

最大的数是： 0

这个样子不是我们想要的最大数了。如何改变写法以避免这样子的bug呢？

我们可以让tmp等于第一个元素，循环从第一个下标开始：

#include 

int main()
{
   int a[]={-23,-56,-98,-104,-187,-188,-786,-342,-218,-436};
    int i,tmp=a[0];
    for(i=1;i<sizeof(a)/sizeof(a[0]);i++)
    {
        if(a[i]>tmp)
            tmp = a[i];
    }
    printf("最大的数是： %d \n",tmp);   
   return 0;
}

最大的数是： -23

上例比先前的代码循环次数少一次，反而没有负数的bug。

那么再来一个问题，最大的成员知道怎么得出，那第二大的成员有办法得出吗？

#include 

int main()
{
   int a[]={123,256,398,104,187,188,786,642,818,436};
    int i,tmp=a[0];
    for(i=1;i<sizeof(a)/sizeof(a[0]);i++)
    {
        if(a[i]>tmp)
            tmp = a[i];
    }
    printf("最大的数是： %d \n",tmp); 
    int max,smax;
    if(a[0]>a[1])
    {    max = a[0];
        smax = a[1];
    }else{
        max = a[1];
        smax = a[0];}
    for(i=2;i<sizeof(a)/sizeof(a[0]);i++)
    {
        if(a[i]>max)
        {
            smax = max;
            max = a[i];
        }
        else if(a[i] smax)
        {
            smax = a[i];
        }
        
    }
    printf("第二大的数为： %d \n",smax);
   return 0;
}

最大的数是： 818
第二大的数为： 786

写程序要先有思路，思路通了再开始写。

数组排序如何逆置呢？

int main()
{
    int a[]= {65,33,48,86,231,665,893,25,38,87,14,58};
    int min =0,max = sizeof(a)/sizeof(a[0])-1;
    while(min<max)
    {
        int tmp = a[min];
        a[min]= a[max];
        a[max]= tmp;
        min++;
        max--;
    }
    int i;
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
        printf("a[%d] = %d \n",i ,a[i]);
    return 0;
}

a[0] = 58
a[1] = 14
a[2] = 87
a[3] = 38
a[4] = 25
a[5] = 893
a[6] = 665
a[7] = 231
a[8] = 86
a[9] = 48
a[10] = 33
a[11] = 65

数组的排序：冒泡

#include 

int main()
{
    int a[]= {65,33,48,86,231,665,893,25,38,87,14,58};
    int i,j;
    for(i = 0;i<sizeof(a)/sizeof(a[0]);i++)
    {
        for(j=1; j<sizeof(a)/sizeof(a[0])-i;j++)
        {
            if(a[j-1]<a[j])
            {
            int tmp = a[j-1];
                a[j-1]= a[j];
                a[j] = tmp;
            }
        }
    
    }
    
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
        printf("a[%d] = %d \n",i ,a[i]);
    return 0;
}

a[0] = 893
a[1] = 665
a[2] = 231
a[3] = 87
a[4] = 86
a[5] = 65
a[6] = 58
a[7] = 48
a[8] = 38
a[9] = 33
a[10] = 25
a[11] = 143

二维数组

二维数组定义示例：

#include 

int main()
{
    int a1[10];
    int a2[2][10];
    int index =0;
    int i,j;
    for(i = 0;i<2; i++)
    {
        for(j=0;j<10;j++)
        {
            a2[i][j] = index++;
        }
    }
    for(i = 0;i<2; i++)
    {
        for(j=0;j<10;j++)
        {
            printf("%d\n",a2[i][j] );
        }
    }
    
    return 0;
}

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include 

int main()
{
    int a1[10];
    int a2[2][10];
    int index =0;
    int i,j;
    for(i = 0;i<2; i++)
    {
        for(j=0;j<10;j++)
        {
            a2[i][j] = index++;
        }
    }
    for(i = 0;i<2; i++)
    {
        for(j=0;j<10;j++)
        {
            printf("%d\n",a2[i][j] );
        }
    }
    printf("%u,%u,%u\n",sizeof(a2),sizeof(a2[0]),sizeof(a2[0][0]));
    printf("%p,%p,%p\n",a2,a2[0],&a2[0][0]);
    
    return 0;
}

运行结果：

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
80,40,4
0x7fff1bdd7f50,0x7fff1bdd7f50,0x7fff1bdd7f50

错误示例：a2[0]=0; a2[0]这里是一个常量，常量是不可以做左值的。

二维数组的初始化：

技术分享

#include 

int main()
{
    int a2[3][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}};
    int i,j;
    for(i=0;i<3;i++)
    {
        for(j=0;j<5;j++)
        {
            printf("a2[%d][%d]= %d \t",i,j,a2[i][j]);
        }
        printf("\n");
    }
    return 0;
}

运行结果：

a2[0][0]= 1 a2[0][1]= 2 a2[0][2]= 3 a2[0][3]= 4 a2[0][4]= 5
a2[1][0]= 6 a2[1][1]= 7 a2[1][2]= 8 a2[1][3]= 9 a2[1][4]= 10
a2[2][0]= 11 a2[2][1]= 12 a2[2][2]= 13 a2[2][3]= 14 a2[2][4]= 15

如果改一下子，数组个数不足，是什么结果呢？

int main()
{
    int a2[3][5]={{1,2,3,4,5},{6,7,8,9,10}};
　　int i,j;
    for(i=0;i<3;i++)
    {
        for(j=0;j<5;j++)
        {
            printf("a2[%d][%d]= %d \t",i,j,a2[i][j]);
        }
        printf("\n");
    }
    return 0;
}

结果：

a2[0][0]= 1 a2[0][1]= 2 a2[0][2]= 3 a2[0][3]= 4 a2[0][4]= 5
a2[1][0]= 6 a2[1][1]= 7 a2[1][2]= 8 a2[1][3]= 9 a2[1][4]= 10
a2[2][0]= 0 a2[2][1]= 0 a2[2][2]= 0 a2[2][3]= 0 a2[2][4]= 0

#include 

int main()
{
    //int a2[3][5]={{1,2,3,4,5},{6,7,8,9,10}};
    int a2[3][5]={0};
    int i,j;
    for(i=0;i<3;i++)
    {
        for(j=0;j<5;j++)
        {
            printf("a2[%d][%d]= %d \t",i,j,a2[i][j]);
        }
        printf("\n");
    }
    return 0;
}

结果：

a2[0][0]= 0 a2[0][1]= 0 a2[0][2]= 0 a2[0][3]= 0 a2[0][4]= 0
a2[1][0]= 0 a2[1][1]= 0 a2[1][2]= 0 a2[1][3]= 0 a2[1][4]= 0
a2[2][0]= 0 a2[2][1]= 0 a2[2][2]= 0 a2[2][3]= 0 a2[2][4]= 0

可以简略写成这样：

#include 

int main()
{
    //int a2[3][5]={{1,2,3,4,5},{6,7,8,9,10}};
    int a2[][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{22,33,43,54,23}};
    int i,j;
    for(i=0;i<sizeof(a2)/sizeof(a2[0]);i++)
    {
        for(j=0;j<sizeof(a2[0])/sizeof(a2[0][0]);j++)
        {
            printf("a2[%d][%d]= %d \t",i,j,a2[i][j]);
        }
        printf("\n");
    }
    return 0;
}

结果：

a2[0][0]= 1 a2[0][1]= 2 a2[0][2]= 3 a2[0][3]= 4 a2[0][4]= 5
a2[1][0]= 6 a2[1][1]= 7 a2[1][2]= 8 a2[1][3]= 9 a2[1][4]= 10
a2[2][0]= 11 a2[2][1]= 12 a2[2][2]= 13 a2[2][3]= 14 a2[2][4]= 15
a2[3][0]= 22 a2[3][1]= 33 a2[3][2]= 43 a2[3][3]= 54 a2[3][4]= 23

这样子的写法，能加和减数组元素，自适应个数：

1 减去

#include 
int main()
{
    //int a2[3][5]={{1,2,3,4,5},{6,7,8,9,10}};
    int a2[][5]={{6,7,8,9,10},{22,33,43,54,23}};
    int i,j;
    for(i=0;i<sizeof(a2)/sizeof(a2[0]);i++)
    {
        for(j=0;j<sizeof(a2[0])/sizeof(a2[0][0]);j++)
        {
            printf("a2[%d][%d]= %d \t",i,j,a2[i][j]);
        }
        printf("\n");
    }
    return 0;
}

a2[0][0]= 6 a2[0][1]= 7 a2[0][2]= 8 a2[0][3]= 9 a2[0][4]= 10
a2[1][0]= 22 a2[1][1]= 33 a2[1][2]= 43 a2[1][3]= 54 a2[1][4]= 23

2,加上

#include 
int main()
{
    //int a2[3][5]={{1,2,3,4,5},{6,7,8,9,10}};
    int a2[][5]={{6,7,8,9,10},{22,33,43,54,23},{},{},{}};
    int i,j;
    for(i=0;i<sizeof(a2)/sizeof(a2[0]);i++)
    {
        for(j=0;j<sizeof(a2[0])/sizeof(a2[0][0]);j++)
        {
            printf("a2[%d][%d]= %d \t",i,j,a2[i][j]);
        }
        printf("\n");
    }
    return 0;
}

a2[0][0]= 6 a2[0][1]= 7 a2[0][2]= 8 a2[0][3]= 9 a2[0][4]= 10
a2[1][0]= 22 a2[1][1]= 33 a2[1][2]= 43 a2[1][3]= 54 a2[1][4]= 23
a2[2][0]= 0 a2[2][1]= 0 a2[2][2]= 0 a2[2][3]= 0 a2[2][4]= 0
a2[3][0]= 0 a2[3][1]= 0 a2[3][2]= 0 a2[3][3]= 0 a2[3][4]= 0
a2[4][0]= 0 a2[4][1]= 0 a2[4][2]= 0 a2[4][3]= 0 a2[4][4]= 0

错误示例：不能写成这样

int a2[][]={{1,2,3,4,5},{6,7,8,9,10}};  //编译器会说：你太懒了，不给你编译~！

多维数组

定义示例：

#include 
int main()
{
    int a3[2][3][4]={{{1,2,3,4},{7,8,9,10},{}},{{},{},{}}};
    int i,j,k,index=0;
    for(i=0;i<2;i++)
    {
        for(j=0;j<3;j++)
        {
            for(k=0;k<4;k++)
            {
                a3[i][j][k]= index++;
            }
        }
    }
    for(i=0;i<2;i++)
    {
        for(j=0;j<3;j++)
        {
            for(k=0;k<4;k++)
            {
                printf("a3[%d][%d][%d]=%d  ",i,j,k,a3[i][j][k]);
            }
            printf("\n");
        }
        
    }
   
    return 0;
}

结果如下：

a3[0][0][0]=0 a3[0][0][1]=1 a3[0][0][2]=2 a3[0][0][3]=3
a3[0][1][0]=4 a3[0][1][1]=5 a3[0][1][2]=6 a3[0][1][3]=7
a3[0][2][0]=8 a3[0][2][1]=9 a3[0][2][2]=10 a3[0][2][3]=11
a3[1][0][0]=12 a3[1][0][1]=13 a3[1][0][2]=14 a3[1][0][3]=15
a3[1][1][0]=16 a3[1][1][1]=17 a3[1][1][2]=18 a3[1][1][3]=19
a3[1][2][0]=20 a3[1][2][1]=21 a3[1][2][2]=22 a3[1][2][3]=23

工程使用中，尽量用比较少的维度数组。

练习：

三维数组排序，从小到大排序。思路：把所有元素遍历给一个一维数组，接着一维数组冒泡排序，最后赋值给三维数组。

#include 
int main()
{
    int a3[2][3][4] = { { { 19,82,73,64 },{ 57,48,39,10 },{89,33,76,42} },{ {97,25,37,81},{44,27,46,90},{88,21,35,41} } };
    int i, j, k, index = 0;
    int b[24] = { 0 };
    for (i = 0; i <2; i++)
    {
        for (j = 0; j <3; j++)
        {
            for (k = 0; k <4; k++)
            {
                b[index] = a3[i][j][k];
                index++;
            }
        }
    }
    
    for (i = 0; i <24; i++)
    {
        for (j = 1; j <24-i; j++)
        {
            if (b[j-1]>b[j])
            {
                int tmp = b[j];
                b[j] = b[j - 1];
                b[j - 1] = tmp;
            }
                    
        }
    }
    index = 0;　　//这里要注意再次初始化0
    for (i = 0; i <2; i++)
    {
        for (j = 0; j <3; j++)
        {
            for (k = 0; k <4; k++)
            {
                a3[i][j][k]=b[index];
                index++;
            }
        }
    }
    for (i = 0; i <2; i++)
    {
        for (j = 0; j <3; j++)
        {
            for (k = 0; k <4; k++)
            {
                printf("a3[%d][%d][%d]=%d\n ", i, j, k, a3[i][j][k]);
            }
            
        }

    }
    getchar();
    return 0;
}

结果：

a3[0][0][0]=10
a3[0][0][1]=19
a3[0][0][2]=21
a3[0][0][3]=25
a3[0][1][0]=27
a3[0][1][1]=33
a3[0][1][2]=35
a3[0][1][3]=37
a3[0][2][0]=39
a3[0][2][1]=41
a3[0][2][2]=42
a3[0][2][3]=44
a3[1][0][0]=46
a3[1][0][1]=48
a3[1][0][2]=57
a3[1][0][3]=64
a3[1][1][0]=73
a3[1][1][1]=76
a3[1][1][2]=81
a3[1][1][3]=82
a3[1][2][0]=88
a3[1][2][1]=89
a3[1][2][2]=90
a3[1][2][3]=97

字符串与字符数组

示例：

#include 
int main()
{
    char a[11];
    a[0]= ‘I‘;
    a[1]= ‘ ‘;
    a[2]= ‘L‘;
    a[3]= ‘o‘;
    a[4]= ‘v‘;
    a[5]= ‘e‘;
    a[6]= ‘ ‘;
    a[7]= ‘Y‘;
    a[8]= ‘o‘;
    a[9]= ‘u‘;
    a[10]= ‘\0‘;
    printf("%s\n",a);
    
    return 0;
}

结果：

I Love You

实际上C语言中没有字符串类型，它就是靠字符数组来表达的。

初始化，也可以这样子表示：

#include 
int main()
{
    char a[11]={‘I‘,‘ ‘,‘L‘,‘o‘,‘v‘,‘e‘,‘ ‘,‘Y‘,‘o‘,‘u‘};
    printf("%s\n",a);
    
    return 0;
}

结果：

I Love You 和上例一样，等价的。

常用的，简化的写法是这样子：

#include 
int main()
{
    //char a[11]={‘I‘,‘ ‘,‘L‘,‘o‘,‘v‘,‘e‘,‘ ‘,‘Y‘,‘o‘,‘u‘};
    char a[11]= "I love You";
    printf("%s\n",a);
    
    return 0;
}

结果：

I Love You 和上两例一模一样。

最简化的写法是：

#include 
int main()
{
    //char a[11]={‘I‘,‘ ‘,‘L‘,‘o‘,‘v‘,‘e‘,‘ ‘,‘Y‘,‘o‘,‘u‘};
    //char a[11]= "I love You";
    char a[] = "I Love You";
    printf("%s\n",a);
    
    int i;
    for(i=0; i<sizeof(a);i++)
    {
        printf("%d\n",a[i]);
    }
    
    return 0;
}

结果如下：

I Love You

73
32
76
111
118
101
32
89
111
117
0

字符串与字符数组的区别

#include 
int main()
{
    char a[] = "I Love You";
    a[3]=0;
    printf("%s\n",a);
    
    int i;
    for(i=0; i<sizeof(a);i++)
    {
        printf("%d\n",a[i]);
    }
    
    return 0;
}

结果如下：

I L //这里输出了前面3个元素，I加“空格”加L
73
32
76
0
118
101
32
89
111
117
0

这里作为数组，元素变化了一个，赋值为了0，个数没有变化。作为字符串，则只打印了前面的3个元素。

字符串与字符数组的区别1就出来了：字符串它以0结尾，后面的不打印。数组呢，把0看成是数组成员。

再看一个出错的示例：

#include 
int main()
{
    char a[7] = "hello";
    a[3]=‘a‘;
    a[5]=‘a‘;
    a[6]=‘a‘;
    
    printf("%s\n",a);
    
    int i;
    for(i=0; i<sizeof(a);i++)
    {
        printf("%d\n",a[i]);
    }
    
    return 0;
}

结果有很大的机率出现乱码：

helao烫~
104
101
108
97
111
97
97

技术分享

总结：数组不要求以0结尾，我们要注意什么时候它是字符串，什么时候当它为数组。

练习：一个字符串为：“I Love You ~~ ”，去掉结尾的空格，怎么做？

思路：应该从字符串的后面开始，去除后面的空格。遍历字符串总长，递减到不为空格时，把下标加上1的元素赋值为0，字符串结束了，空格消除！

#include 
int main()
{
    char a[] = "I Love You ~~~                     ";
    int index=0;
    while(a[index])
    {
        index++;
    }
    int i;
    for(i= index-1 ; i>=0 ; i--)
    {
        if(a[i]!=‘ ‘)
        {
            a[i+1]=0;
            break;
        }
    
    }
    printf("(%s)\n",a);
    
    
    return 0;
}

运行如下：

(I Love You ~~~)

每天一得数组

推荐阅读

main
Java实现大数乘法（分治算法）

本文介绍了使用Java实现大数乘法的分治算法，包括输入数据的处理、普通大数乘法的结果和Karatsuba大数乘法的结果。通过改变long类型可以适应不同范围的大数乘法计算。 ... [详细]

蜡笔小新 2023-12-14 15:43:50
int
java 线程死锁模拟

1，关于死锁的理解死锁，我们可以简单的理解为是两个线程同时使用同一资源，两个线程又得不到相应的资源而造成永无相互等待的情况。 2，模拟死锁背景介绍：我们创建一个朋友 ... [详细]

蜡笔小新 2023-12-13 19:12:25
main
动态规划算法的基本步骤及最长递增子序列问题详解

本文详细介绍了动态规划算法的基本步骤，包括划分阶段、选择状态、决策和状态转移方程，并以最长递增子序列问题为例进行了详细解析。动态规划算法的有效性依赖于问题本身所具有的最优子结构性质和子问题重叠性质。通过将子问题的解保存在一个表中，在以后尽可能多地利用这些子问题的解，从而提高算法的效率。 ... [详细]

蜡笔小新 2023-12-13 15:38:19
main
猜字母游戏

猜字母游戏猜字母游戏——设计数据结构猜字母游戏——设计程序结构猜字母游戏——实现字母生成方法猜字母游戏——实现字母检测方法猜字母游戏——实现主方法1猜字母游戏——设计数据结构1.1 ... [详细]

蜡笔小新 2023-12-13 12:04:03
int
C#之数据集：DataSet对象的使用及相关方法详解

本文介绍了C#中数据集DataSet对象的使用及相关方法详解，包括DataSet对象的概述、与数据关系对象的互联、Rows集合和Columns集合的组成，以及DataSet对象常用的方法之一——Merge方法的使用。通过本文的阅读，读者可以了解到DataSet对象在C#中的重要性和使用方法。 ... [详细]

蜡笔小新 2023-12-14 12:09:13
main
OC学习笔记之@property和@synthesize

本文介绍了OC学习笔记中的@property和@synthesize，包括属性的定义和合成的使用方法。通过示例代码详细讲解了@property和@synthesize的作用和用法。 ... [详细]

蜡笔小新 2023-12-14 12:05:06
int
《数据结构》学习笔记3——串匹配算法性能评估

本文主要讨论串匹配算法的性能评估，包括模式匹配、字符种类数量、算法复杂度等内容。通过借助C++中的头文件和库，可以实现对串的匹配操作。其中蛮力算法的复杂度为O(m*n)，通过随机取出长度为m的子串作为模式P，在文本T中进行匹配，统计平均复杂度。对于成功和失败的匹配分别进行测试，分析其平均复杂度。详情请参考相关学习资源。 ... [详细]

蜡笔小新 2023-12-13 16:16:05
select
高质量SQL书写的30条建议

本文提供了30条关于优化SQL的建议，包括避免使用select *，使用具体字段，以及使用limit 1等。这些建议是基于实际开发经验总结出来的，旨在帮助读者优化SQL查询。 ... [详细]

蜡笔小新 2023-12-13 13:24:33
int
Python解析C语言结构体

本文介绍了使用Python解析C语言结构体的方法，包括定义基本类型和结构体类型的字典，并提供了一个示例代码，展示了如何解析C语言结构体。 ... [详细]

蜡笔小新 2023-12-11 18:45:50
int
C语言指针的应用与价值探讨与阐述

本文探讨了C语言中指针的应用与价值，指针在C语言中具有灵活性和可变性，通过指针可以操作系统内存和控制外部I/O端口。文章介绍了指针变量和指针的指向变量的含义和用法，以及判断变量数据类型和指向变量或成员变量的类型的方法。还讨论了指针访问数组元素和下标法数组元素的等价关系，以及指针作为函数参数可以改变主调函数变量的值的特点。此外，文章还提到了指针在动态存储分配、链表创建和相关操作中的应用，以及类成员指针与外部变量的区分方法。通过本文的阐述，读者可以更好地理解和应用C语言中的指针。 ... [详细]

蜡笔小新 2023-12-13 15:02:30
main
指针的引用以及在什么情况下使用指针的引用

本文介绍了指针的概念以及在函数调用时使用指针作为参数的情况。指针存放的是变量的地址，通过指针可以修改指针所指的变量的值。然而，如果想要修改指针的指向，就需要使用指针的引用。文章还通过一个简单的示例代码解释了指针的引用的使用方法，并思考了在修改指针的指向后，取指针的输出结果。 ... [详细]

蜡笔小新 2023-12-13 12:54:29
main
工程中添加Android Dependencies

在project.properties添加#Projecttarget.targetandroid-19android.library.reference.1..Sliding ... [详细]

蜡笔小新 2023-12-13 12:08:09
main
使用C语言命令行参数在Windows上启动程序并传递参数

本文介绍了在Windows系统上使用C语言命令行参数启动程序并传递参数的方法，包括接收参数程序的代码和bat文件的编写方法，同时给出了程序运行的结果。 ... [详细]

蜡笔小新 2023-12-12 10:21:44
main
C语言判断正整数能否被整除的程序

本文介绍了使用C语言编写的判断正整数能否被整除的程序，包括输入一个三位正整数，判断是否能被3整除且至少包含数字3的方法。同时还介绍了使用qsort函数进行快速排序的算法。 ... [详细]

蜡笔小新 2023-12-11 19:40:15
int
C语言常量与变量的深入理解及其影响

本文深入讲解了C语言中常量与变量的概念及其深入实质，强调了对常量和变量的理解对于学习指针等后续内容的重要性。详细介绍了常量的分类和特点，以及变量的定义和分类。同时指出了常量和变量在程序中的作用及其对内存空间的影响，类似于const关键字的只读属性。此外，还提及了常量和变量在实际应用中可能出现的问题，如段错误和野指针。 ... [详细]

蜡笔小新 2023-12-11 09:28:31

akun

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章