• C、C++语言容易出错的几个地方


    1. sizeof()和strlen()函数

    sizeof常见标准用法(1)、(2)、(3) [摘自C++ Reference]:

    //(1)
    char buff[6];
    strncpy(buff, argv[1], sizeof(buff));

    //(2)
    int array[] = { 3, 1, 4, 1, 5, 9 };
    unsigned int array_size = sizeof(array) / sizeof(array[0]);

    //(3)
    typedef struct data_type {
    int age;
    char name[20];
    } data;

    data *bob;
    bob = (data*) malloc( sizeof(data) );
    if( bob != NULL ) {
    bob->age = 22;
    strcpy( bob->name, "Robert" );
    printf( "%s is %d years old\n", bob->name, bob->age );
    }
    free( bob );

    可见,sizeof主要用于求某种数据(例如int,数组,字符串,指针,结构体…)的size,例如:

    char str[]="hello";

    char *p1=str;

    此时,用sizeof(str)得到的是6,因为hell0是5个字符,系统储存的时候会在hello的末尾加上结束标识\0,一共为6个字符;

           而sizeof(p1)得到的却是4,它求得的是指针变量p1的长度,在32位机器上,一个地址都是32位,即4个字节。

           用sizeof(*p1)得到的是1,因为*p1定义为char,相当于一个字符,所以只占一个字节。

           用strlen(str),得到的会是5,因为strlen求得的长度不包括最后的\0。

        用strlen(p1),得到的是5,与strlen(str)等价。

    上面的是sizeof和strlen的区别,也是 指针字符串和 数组字符串 的区别。

    编程时这种错误非常隐秘,见下面的一个例子。

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    int main( )
    {
    char *src="hello world";
    char *dest=NULL;
    int len=strlen(src);//这里很容易出错,写成sizeof(src)就是求指针的长度,即4
    dest=(char *)malloc(len+1);//这里很容易出错,写成len
    char *d=dest;
    char *s=&src[len-1]; //这里很容易出错,写成len
    while(len--!=0)
    *d++=*s--;
    *d='\0'; //这句很容易漏写
    printf("%s\n", dest);
    free(dest); //这句很容易漏写
    return 0;
    }

    注意,我上面这个C语言程序是在Linux平台下gcc编译的,Windows平台下的VC6不支持即用即声明的形式,必须先定义后使用。用VC6编译可以改成下面的形式:

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    int main( )
    {
    char *src, *dest, *d, *s;
    int len;
    src="hello world";
    dest=NULL;
    len=strlen(src);
    dest=(char *)malloc(len+1);
    d=dest;
    s=&src[len-1];
    while(len--!=0)
    *d++=*s--;
    *d='\0';
    printf("%s\n", dest);
    free(dest);
    return 0;
    }

    首先说明一下malloc函数和free函数的使用

        #include <stdlib.h>

        void *malloc( unsigned int size );

    它的功能是在内存的动态存储区分配一个长度为size字节的连续空间。函数返回的是一个指向分配域其实地址的指针,这个指针的类型是void类型。如果函数未能执行成功则返回一个空指针NULL,使用这个函数必须包含头文件stdio.h。

        void类型的指针,指向一个类型未定的变量,也就是说它可以指向char类型变量,也可以指向int类型或其它类型。因此在将它的值赋值给另外一个指针时要进行强制类型转换,例如:

    char *p1="123456";

    void *p2="abcdef";

    p1=(char *)p2;//两者类型必须相同,也可以p2=(void *)p1;

           malloc函数必须和free函数成对出现,使用完了free(dest);

    2. 数组中易错的地方

    分析下面这段小程序:

    #include<stdio.h>

    void main()

    {

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

           int *ptr=(int *)(&a+1);

           printf("%d, %d\n", *(a+1), *(ptr-1));

    }

    以及下面这个程序:

    #include <stdlib.h>
    #include <stdio.h>
    static void show_str_pointer(const char **ppstr)
    {
    printf("%s\n", *ppstr);
    }
    int main()
    {
    char array[4] = "abc";
    char *pointer = "abc";
    show_str_pointer(&pointer);
    show_str_pointer(&array);
    return 0;
    }

    执行结果为:

    abc

    7�

           &array与array的语义相同。在这里指针与数组是不能互换的。&pointer为指针的地址,与show_str_pointer参数char **ppstr指向指针的指针的变量类型相同。而&array仍然为数组地址,与参数char **ppstr的类型不符。

    3. 数组的最大长度问题

           int n[1000000];这样肯定是不行的,因为这样定义的数组用的是栈内存,系统默认值为最大1Mb,一个int型占4字节这样最大可以申请1024*1024/4=264144个,如果考虑到系统自身的占用最大值约为25000个。

           int *p=(int *)malloc(1000000*sizeof(int));,这样用的是堆内存,只要你内存有那么多的连续空间就可以。例子如下:

    #include<stdio.h>
    #include<malloc.h>

    int main()
    {
    int *p=(int *)malloc(1000000*sizeof(int));
    //int p[1000000];
    int i=0;
    for(;i<1000000;i++)
    printf("%d\n",p[i]=i);
    free(p);
    return 0;
    }

    如果非要用数组的话,一般这样写,不能再大了:

    #define MAXSIZE 250000

    int a[MAXSIZE];

    2. fscanf和fprintf函数

           将文件中的数据读出来存入指定的指针位置,例如fscanf (fp,"%d", &a[i]);

           将数据存入文件中可以用fprintf函数,但是对于二进制文件,写成fprintf(fp, "%d", a[i]);就不对,因为存入的是%d格式是十进制的,所以此时不要用fprintf,换成fwrite即可。

     有关二进制文件的读写参加下面一个程序:

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #define DATASIZE 250000

    int main(int argc, char ** argv)
    {
    const char * file_name = "out.dat";
    FILE * fp = fopen(file_name, "wb");//必须放在其他变量的定义之前
    int i, a, b[DATASIZE];
    srand( time(NULL) );
    for(i=0; i<DATASIZE; i++)
    {
    a=rand()%100;
    fwrite(&a, sizeof(int), 1, fp);
    }
    fclose(fp);

    fp = fopen(file_name, "rb");
    fread(&b, sizeof(int), DATASIZE, fp);

    for(i=0; i<200; i++)
    printf("%d ", b[i]);
    printf("\n");

    return 0;
    }

    程序说明:随机生成25万个0~100的整数以二进制的形式存入文件out.dat中,然后再读取文件out.dat中的整数挨个赋值给数组b[DATASIZE],最后打印出该数组的前200个数。

     3. 递归栈空间溢出

           我们知道快速排序通常是用递归算法写的,虽然说号称是速度最快的(其实也不是最快的),但是我排20万个整数它就受不鸟了(貌似系统给栈空间分配的大小为2M或者8M,快速排序最坏情况下,递归深度为n,所需要的栈空间为O(n),一个整数4位32个字节,100W*32那就有30多M了,栈空间必定溢出),排18万个整数的时候近似时间复杂度约为1.4亿,运行了0.497秒,而VC6自带库函数里面的那个qsort()要慢很多,用了1.942秒,堆排序只用了0.032秒(太给力了!),还有就是哥那个优化过的希尔排序,用了8.518秒,复杂度约为16亿,伤不起啊!

           我把快速排序稍微改进一下,用首中尾三者取中作为基准的办法,速度肯定是提高了不少,但是可排序的元素个数锐减到了3万个,4万个元素都可能导致递归栈空间溢出,5万个元素想都别想了,所以呀这个快速排序的极限是排3万个元素。而当我用3万个元素去测试的时候,快排用了0.169秒,堆排序用了0.006秒,快慢一眼明了。

           当待排序的数据量比较大时,你就别想用什么冒泡排序、直接选择排序、直接插入排序等,效率太低了!最好是用堆排序。

    补充一点:

           递归算法的实现过程:是通过栈实现的,例如下面一个求阶乘的算法:

    int Fac(n)

    int n;

    {

      if( n==1 ) return 1;

      else return n*Fac(n-1);

    }

           系统最初是不会去计算的,它会在内存中开辟一个栈空间,假如说n=3,那么首先3*Fac(2)入栈,占据栈底的位置,然后2*Fac(1)入栈,此时Fac(1)就不再递归了,所以没有元素再入栈了,Fac(1)返回值1,然后2*Fac(1)、3*Fac(2)依次出栈,最终出栈的是数字6,这就是3的阶乘。

           由此可见,递归的函数越复杂,数据量越大,变量越多,那么占用的栈空间就越大,因为栈的每一层都要保存这些,其实很多的重复的,但是依然保存了,只有到该层出栈的时候才释放。编译器就是这样的,没有太多的优化,内存开销相当的大,所以——少用递归,慎用递归!

  • 相关阅读:
    正则表达式
    浏览器 User-Agent 大全
    python3爬虫开发实战 第六课 爬虫基本流程
    python3爬虫开发实战 第五课 常用库的安装
    python3爬虫开发实战 第四课 MySQL
    python3爬虫开发实战 第三课 Redis数据库
    python3爬虫开发实战 第二课 MongoDB安装
    python3爬虫开发实战 第一课 python安装和Pycharm安装
    批处理——数据库
    Aop所需包
  • 原文地址:https://www.cnblogs.com/zollty/p/2389935.html
Copyright © 2020-2023  润新知