精华内容
下载资源
问答
  • C语言模块化中头文件.h的设计

    千次阅读 2011-11-24 21:19:45
    一个项目会切割成很多模块模块模块之前的联系,需要通过头文件来联系起来,这就是为什么先设计头文件,再实现.c的原因  总结一下编码历程: 1,刚开始学C,把各种结构体,函数声明放一个.h中; 2,接着...
           一个项目会切割成很多模块,模块与模块之前的联系,需要通过头文件来联系起来,这就是为什么先设计头文件,再实现.c的原因

           总结一下编码历程:
    1,刚开始学C,把各种结构体,函数声明放一个.h中;
    2,接着发现,要学会隐藏,把结构体,内部函数的声明放模块使用的.h,把之前一个大的.h切割成N多的模块.h
    3,最后发现,把结构体,内部函数声明全部放模块.c中(如果没有依赖的话,甚至一个内部函数声明都不用写);
           模块.h只放外部接口函数声明,其它全部隐藏起来,不对别的模块开放

           一个模块A会用到模块B的引用,通常的设计如下:
    ///
    module_b.h:

    #ifndef _MODULE_B_H_
    #define _MODULE_B_H_

    struct B_s
    {
     int a;
     int b;
    };
    typedef struct B_s B_t;

    int func_b();

    #endif
    ///
    module_a.h:

    #ifndef _MODULE_A_H_
    #define _MODULE_A_H_

    #include "module_b.h"//不好的设计

    struct A_s;
    typedef struct A_s A_t;

    int func_a(B_t *_data);

    #endif
    ///
           实际上A模块只是用到B模块的方法,现在却调用了module_b.h,B模块的外部接口函数func_b暴露给A模块了,
           把结构体放到module_b.c中去,头文件中只做一个不完整的定义,修改后的设计:
    ///
    module_b.h:

    #ifndef _MODULE_B_H_
    #define _MODULE_B_H_

    struct B_s;//这里是个不完整定义
    typedef struct B_s B_t;

    int func_b();

    #endif
    ///
    module_a.h:

    #ifndef _MODULE_A_H_
    #define _MODULE_A_H_

    struct B_s;//这里是个不完整定义

    struct A_s;
    typedef struct A_s A_t;

    int func_a(struct B_s *_data);

    #endif
    ///
           这样做的原则就是,头文件体积尽量下,不开放给模块的信息,都不要写到头文件.h中
           另外,typedef的使用,到底要不要?许多大牛们反对利用它,(的确上面代码重新设计后就必须采用struct B_s结构,如果采用B_t,会有所担心module_a.h和module_b.h被同一个引用,最终导致重复定义,大牛们说得很有道理),但是利用它的确可以省去写N多union,struct的麻烦,而且***_t只是在自己的模块中用,至于其他模块的头文件中的引用,没办法,还是老实的用union,struct
           log4c中就是这样用的

           另外,如果模块A和模块B相互引用呢?这就相当于C++中的friend
    展开全文
  • C语言是结构化和模块化的语言,它是面向过程的。但它也可以模拟C++实现面向对象的功能。那么什么是对象呢?对象就是一个包含数据以及于这些数据有关的操作的集合,也就是包含数据成员和操作代码(即成员函数)。用...
    C语言是结构化和模块化的语言,它是面向过程的。但它也可以模拟C++实现面向对象的功能。那么什么是对象呢?对象就是一个包含数据以及于这些数据有关的操作的集合,也就是包含数据成员和操作代码(即成员函数)。用C语言实现面向对象功能主要就是实现拟“类”的继承,函数的重载等操作,这些主要是通过结构体和指针函数实现的。
    

          在C++和Java中,多态行为是由一种动态连接机实现的,比如,在C++中定义如下的类 Base 和它的子类 Sub:

    class Base {
            int data;
    public:
            Base() : data(3) {}
            virtual int getData() const {
                    return data;
            }
    };

    class Sub:public Base {
            int data;
    public:
            Sub() : data(5) {}
            int getData() const {
                    return data;
            }
    };

       那么如果有一个Base 类型的指针指向了一个Sub类,通过这个指针调用getData()时将返回子类Sub中的data:初始值5。这样,如果有一个储存基类型指针的数组, 但这些指针有的指向基类,有的指向子类,那么我就可以通过指针统一地调用 getData() 函数,依然能够得到正确的值。
    怎么在C中也实现类似的功能呢?

     要想根据基类的指针正确地选择应该调用的函数,一个合适的备选方案是用函数指针,即在基类的结构中定义一个函数指针,这个函数指针的值将根据具体对象的类别设置,比如上面的C++代码可以用C写成这样:

    struct Base {
            int data;
            int (*getData)( struct Base * );
    };

    struct Sub {
            struct Base base;
            int data;
    };

       这样,如果有一个struct Base 型的指针 base,通过 base->getData(base) 就可以得到正确的值,这样就实现了我们刚才的目的。但是如果有一个真正的 struct Sub 型的指针 sub,要想通过 sub 来调用正确的 getData,则至少要经过两次强制类型转换(如果不想让编译器发出警告的话)。这在写代码时是比较麻烦的。我们可以在sub中也添加一个函数指针,它 指向专门为 struct Sub 写的函数,这样就可以解决这种不便之处:

    struct Base {
            int data;
            int (*getData)( struct Base * );
    };

    struct Sub {
            struct Base base;
            int (*getData)( struct Sub * );
            int data;
    };

      这样一来,我们需要适当地初始化这些指针,让它们指向合适的值。那么这种初始化的工作由谁来做呢?我们可以分别为两个类写初始化函数,类似于C++和Java中的构造函数,同时,在必要的时候我们也可以写出它们的析构函数用来释放内存空间。完整的例子如下:

    #include<stdio.h>
    #include<stdlib.h>
    struct Base {
            int data;
            int (*getData)( struct Base * );
    };

    struct Sub {
            struct Base base;
            int (*getData)( struct Sub * );
            int data;
    };

    int getDataForBase( struct Base * base ) {
            return base->data;
    }

    int getDataForSubBase( struct Base * base ) {
            return ((struct Sub *)base)->data;
    }
    int getDataForSub( struct Sub * sub ) {
            /*这个函数和上面的函数只有参数类型不同。
             * 如果代码太长我们可以直接调用上面的函数。
             * 我们也可以省略这个函数而把 sub 中的函数指针
             * 设成和 Base 类相同,这样在调用时如果传递 sub
             * 指针,那么编译器会发出警告。*/
            return sub->data;
    }

    /* Base 的“构造函数” */
    void Base_init( struct Base * base ) {
            base->data = 3;
            base->getData = getDataForBase;
    }

    /* Sub 的“构造函数” */
    void Sub_init( struct Sub * sub ) {
            Base_init( (struct Base*)sub );        /* 在C++中,子类的构造方法默认将调用父类的无参数构造方法。*/
            ((struct Base*)sub)->getData = getDataForSubBase;/* 设置函数指针 */
            sub->getData = getDataForSub;        /* 设置函数指针 */
            sub->data = 5;
    }

    /* Base 和 Sub 的析构函数: */
    void Base_destroy( struct Base * base) {}
    void Sub_destroy( struct Sub * sub) {}

    int main()
    {
            struct Base * base = (struct Base*)malloc(sizeof(struct Base));
            Base_init(base);
            struct Sub * sub = (struct Sub*)malloc(sizeof(struct Sub));
            Sub_init(sub);
            struct Base * subbase = (struct Base*)sub;
            /*从下面的语句可以看出,不论是 Base 型的指针指向 Base 型,Base 型指针指向 Sub 型,还是 Sub 型指针指向 Sub 型,调用函数的格式都是统一的。*/
            printf( "%d\n%d\n%d\n", base->getData(base), sub->getData(sub), subbase->getData(subbase) );
            free(base);        /*适当地换成析构函数*/
            free(sub);        /*适当地换成析构函数*/
    }

      这样实现动态连接的类显然就不能通过切割内存来实现类型转换了,如果试图把一个Sub类强行切割成Base类,那么得到的Base类中的函数指针就可能指向错误的函数。我们必须在切割之后重新设置Base中函数指针的值。

      讨论过这些之后,我们设想一下在C语言中可不可以实现数据结构和算法的通用函数。在以前学习C语言的时候,即使是简单的单链表操作,在一个程序中实现的操作函数也不能直接拿到另一个程序中使用,因为链表的节点结构不同。而现在,只要定义一个基本的节点模板:
    struct listNode {
            struct listNode * next;
    };
    我们就可以写出针对它的操作函数。而在使用时,我们定义一个继承它的类:
    struct myListNode {
            struct listNode node;
            int data;
    };
    通过强制类型转换,就可以使用通用函数了。用这种方法可以实现链表的创建、插入、删除等操作的通用函数。如果要在链表中查找指定的节点呢?运用函数指针将判别函数传入通用函数,这样查找也实现了。

    展开全文
  • C语言是结构化和模块化的语言,它是面向过程的。但它也可以模拟C++实现面向对象的功能。那么什么是对象呢?对象就是一个包含数据以及于这些数据有关的操作的集合,也就是包含数据成员和操作代码(即成员函数)。用...

       C语言是结构化和模块化的语言,它是面向过程的。但它也可以模拟C++实现面向对象的功能。那么什么是对象呢?对象就是一个包含数据以及于这些数据有关的操作的集合,也就是包含数据成员和操作代码(即成员函数)。用C语言实现面向对象功能主要就是实现拟“类”的继承,函数的重载等操作,这些主要是通过结构体和指针函数实现的。

          在C++和Java中,多态行为是由一种动态连接机实现的,比如,在C++中定义如下的类 Base 和它的子类 Sub:

    class Base {
            int data;
    public:
            Base() : data(3) {}
            virtual int getData() const {
                    return data;
            }
    };

    class Sub:public Base {
            int data;
    public:
            Sub() : data(5) {}
            int getData() const {
                    return data;
            }
    };

       那么如果有一个Base 类型的指针指向了一个Sub类,通过这个指针调用getData()时将返回子类Sub中的data:初始值5。这样,如果有一个储存基类型指针的数组, 但这些指针有的指向基类,有的指向子类,那么我就可以通过指针统一地调用 getData() 函数,依然能够得到正确的值。
    怎么在C中也实现类似的功能呢?

     要想根据基类的指针正确地选择应该调用的函数,一个合适的备选方案是用函数指针,即在基类的结构中定义一个函数指针,这个函数指针的值将根据具体对象的类别设置,比如上面的C++代码可以用C写成这样:

    struct Base {
            int data;
            int (*getData)( struct Base * );
    };

    struct Sub {
            struct Base base;
            int data;
    };

       这样,如果有一个struct Base 型的指针 base,通过 base->getData(base) 就可以得到正确的值,这样就实现了我们刚才的目的。但是如果有一个真正的 struct Sub 型的指针 sub,要想通过 sub 来调用正确的 getData,则至少要经过两次强制类型转换(如果不想让编译器发出警告的话)。这在写代码时是比较麻烦的。我们可以在sub中也添加一个函数指针,它 指向专门为 struct Sub 写的函数,这样就可以解决这种不便之处:

    struct Base {
            int data;
            int (*getData)( struct Base * );
    };

    struct Sub {
            struct Base base;
            int (*getData)( struct Sub * );
            int data;
    };

      这样一来,我们需要适当地初始化这些指针,让它们指向合适的值。那么这种初始化的工作由谁来做呢?我们可以分别为两个类写初始化函数,类似于C++和Java中的构造函数,同时,在必要的时候我们也可以写出它们的析构函数用来释放内存空间。完整的例子如下:

    #include<stdio.h>
    #include<stdlib.h>
    struct Base {
            int data;
            int (*getData)( struct Base * );
    };

    struct Sub {
            struct Base base;
            int (*getData)( struct Sub * );
            int data;
    };

    int getDataForBase( struct Base * base ) {
            return base->data;
    }

    int getDataForSubBase( struct Base * base ) {
            return ((struct Sub *)base)->data;
    }
    int getDataForSub( struct Sub * sub ) {
            /*这个函数和上面的函数只有参数类型不同。
             * 如果代码太长我们可以直接调用上面的函数。
             * 我们也可以省略这个函数而把 sub 中的函数指针
             * 设成和 Base 类相同,这样在调用时如果传递 sub 
             * 指针,那么编译器会发出警告。*/
            return sub->data;
    }

    /* Base 的“构造函数” */
    void Base_init( struct Base * base ) {
            base->data = 3;
            base->getData = getDataForBase;
    }

    /* Sub 的“构造函数” */
    void Sub_init( struct Sub * sub ) {
            Base_init( (struct Base*)sub );        /* 在C++中,子类的构造方法默认将调用父类的无参数构造方法。*/
            ((struct Base*)sub)->getData = getDataForSubBase;/* 设置函数指针 */
            sub->getData = getDataForSub;        /* 设置函数指针 */
            sub->data = 5;
    }

    /* Base 和 Sub 的析构函数: */
    void Base_destroy( struct Base * base) {}
    void Sub_destroy( struct Sub * sub) {}

    int main()
    {
            struct Base * base = (struct Base*)malloc(sizeof(struct Base));
            Base_init(base);
            struct Sub * sub = (struct Sub*)malloc(sizeof(struct Sub));
            Sub_init(sub);
            struct Base * subbase = (struct Base*)sub;
            /*从下面的语句可以看出,不论是 Base 型的指针指向 Base 型,Base 型指针指向 Sub 型,还是 Sub 型指针指向 Sub 型,调用函数的格式都是统一的。*/
            printf( "%d\n%d\n%d\n", base->getData(base), sub->getData(sub), subbase->getData(subbase) );
            free(base);        /*适当地换成析构函数*/
            free(sub);        /*适当地换成析构函数*/
    }

      这样实现动态连接的类显然就不能通过切割内存来实现类型转换了,如果试图把一个Sub类强行切割成Base类,那么得到的Base类中的函数指针就可能指向错误的函数。我们必须在切割之后重新设置Base中函数指针的值。

      讨论过这些之后,我们设想一下在C语言中可不可以实现数据结构和算法的通用函数。在以前学习C语言的时候,即使是简单的单链表操作,在一个程序中实现的操作函数也不能直接拿到另一个程序中使用,因为链表的节点结构不同。而现在,只要定义一个基本的节点模板:
    struct listNode {
            struct listNode * next;
    };
    我们就可以写出针对它的操作函数。而在使用时,我们定义一个继承它的类:
    struct myListNode {
            struct listNode node;
            int data;
    };
    通过强制类型转换,就可以使用通用函数了。用这种方法可以实现链表的创建、插入、删除等操作的通用函数。如果要在链表中查找指定的节点呢?运用函数指针将判别函数传入通用函数,这样查找也实现了。

    转载于:https://www.cnblogs.com/pengkunfan/p/3486611.html

    展开全文
  • 编译原理 C语言实现词法分析

    热门讨论 2011-05-14 00:48:46
    通过设计编制调试一个具体的词法分析程序,加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 编制一个读单词过程,从输入的源程序中,识别出各个具有独立...
  • c语言教程(课件)8.ppt

    2020-08-01 06:14:04
    引子 第8章 函 数 C语言通过函数来实现模块化程序设计的所以较大的C语言应用程序往往是由多个函数组成的每个函数分别对应各自的功能模块 7.1 概述 7.2 函数的定义与调用 7.3 函数的嵌套调用与递归调用 7.3 数组...
  • C语言程序设计基础 刘新国 1 第五章 函数 结构程序设计(Structured Programming) 将复杂程序分解为若干个简单的模块用函数进行实现 模块之间相对独立通过参数进行调用 C语言中的函数 众多函数是平等的兄弟关系 ...
  • C语言之函数

    2018-03-31 17:09:00
    对于一个层序来说,模块化设计是极其重要的,而函数就体现了一种分而治之的思想,使用函数可以避免程序中代码的重复使用、另外也可以对程序起到自顶向下,逐步细化的作用,同时使程序在测试和优化更加容易。...

    函数

    对于初学C语言的人来说可能会问函数是什么?在这里我有一个通俗的解释;函数就是一个盒子,在这个盒子里面可以封装你想实现的功能,之后通过主函数进行调用即可

    为什么要使用函数?

    对于一个层序来说,模块化设计是极其重要的,而函数就体现了一种分而治之的思想,使用函数可以避免程序中代码的重复使用、另外也可以对程序起到自顶向下,逐步细化的作用,同时使程序在测试和优化更加容易。对于一门语言来说,它里面一般都会有定义好的函数库,当开发者需要使用的时候可以直接进行调用。C语言也是如此,他也拥有自己的标准库函数。如果自身的标准库函数达不到开发者的开发需求,那么开发者也可以使用自定义的函数;当然,这些函数都是由main()函数统一进行调用管理的。

    举一个关于函数的简单的例子:

    eg:用函数写一个计算整数n的阶乘。

    long Fact(int n)      //声明一个函数,函数名为Fact,在函数名括号里的为形式参数

    {

      int i;

      long result=1;

      for(int i=2;i<=n;i++)

      {

      result *=i;        //实现阶乘的功能

      }

      return result;      //返回函数的结果

    }

    对于一个函数来说,首先应当明白他的功能,这个例子中的函数是用来计算阶乘的,函数名后的形式参数代表一个函数的入口,如果不需要入口,就用void来代表形参里面的内容;另外,一个函数也应该有相应的返回值类型,在声明函数的时候要进行表明,如果一个函数没有返回值类型,那么这个函数名前面就要用void来进行声明。

    那么将上面的函数合并成一个完整的程序:

    #include<stdio.h>
    long Fact(int n);    //函数原型
    int main()
    {
      int m;
      long ret;
      printf("please enter m:");
      scanf("%d",&m);
      ret=Fact(m);    //调用函数,把函数的结果传给ret
      printf("%d!=%ld\n",m,ret);
      return 0;
    }
    long Fact(int n)    //相当于一个子函数
    {
      int i;
      long result=1;
      for(i=2;i<=n;i++)
      {
      result*=i;
      }
      return result;
    }

    函数原型的主要作用是告诉编译器,函数Fact()将会从调用程序接收一个int型参数,编译器检查函数调用语句中实参的类型和数量于函数原型是否匹配。

    在函数中还要特别注意的是函数的封装,也就是对于这个盒子的保护作用,增加函数的安全判断,就像是上面的程序不可以输入负数一样,这也是增强了程序的健壮性。

    函数设计的基本原则:

    1.函数的规模要小,因为这样的代码易于维护,出错几率比较小;

    2.每个函数的功能尽量要单一,不要设计具有多个用途的函数。

    3.每个函数只有一个入口和一个出口。

    4.在函数接口中清楚的定义函数的行为,包括入口参数,出口参数,返回类型,异常处理等,让调用者清楚函数所能进行的操作是否成功,应尽可能的考虑出错的情况。

    5.在函数的入口处,对参数的有效性进行检查。

    6.在执行某些敏感性操作之前,应检查操作数及其类型的合法性,以避免发生数据除零,数据溢出而引起的错误。

    函数的递归调用和递归函数

    首先举个例子:斐波那契数列问题。

    用递归方法实现:

    #include<stdio.h>
    long Fact(int n);
    int main()
    {
      int n,i,x;
      printf("Input n:");
      scanf("%d",&n);
      for(i=1;i<=n;i++)
      {
      x=Fact(i);
      printf("Fact(%d)=%d\n",i,x);
      }
      return 0;
    }
    long Fact(int n)
    {
      if(n==0)
      return 0;
      else if(n==1)
      return 1;
      else
      return (Fact(n-1)+Fact(n-2));
    }

    所谓的递归就是函数自身的一种调用,调用自己来实现功能;递归的用法在内存空间的占用上浪费很大,所以对于一个问题而言可能不是最优的算法.为提高程序的执行效率,应尽量用迭代形式替代递归形式

     

    转载于:https://www.cnblogs.com/huolan520/p/8683025.html

    展开全文
  • c语言课程设计

    2016-05-23 21:25:00
    1.查看该程序,体会C语言的中的核心语句是如何使用的 1)该程序采用函数组成模块化结构 2)main函数中,首先调用menu()函数产生菜单 3)然后通过不停接收用户的按键,分别判断是什么操作 4)然后设置飞机和子弹移动 5)...
  • C语言钩子函数详解

    千次阅读 2021-01-23 21:48:15
    正好最近又遇到了这个钩子函数,所以通过例子来详细讲解一下钩子函数,顺便也科普C语言一个完整的功能模块创建规范是什么样的。 钩子函数本质上一个函数指针。这时候讲一些钩子函数什么作用,为什么要用钩子函数,...
  • C语言的科学和艺术.pdf

    热门讨论 2012-01-19 14:09:05
    C语言的科学和艺术》采用了库函数的方法,强调抽象的原则,详细阐述了库和模块化开发。此外,《C语言的科学和艺术》还利用大量实例讲述解决问题的全过程,对开发过程中常见的错误也给出了解决和避免的方法。...
  • c语言编写单片机技巧

    2009-04-19 12:15:17
    此外,C语言程序具有完善的模块程序结构,从而为软件开发中采用模块化程序设计方法提供了有力的保障。因此,使用C语言进行程序设计已成为软件开发的一个主流。用C语言来编写目标系统软件,会大大缩短开发周期,且...
  • 第7章:用函数实现模块化程序设计 7.1为什么要用函数  7.2怎样定义函数  7.2.1为什么要定义函数  7.2.2定义函数的方法  7.3调用函数174  7.3.1函数调用的形式  7.3.2函数调用时的数据传递  7.3.3函数调用的...
  • 本系统通过模块化设计进行开发,包含三个.c文件(main.c、function.c和extra.c)、一个function.h文件和一个student.txt文件。实现的功能有:对学生的学号自动分配,对学生数据的读取、插入、删除、查询、输出等,...
  • 答:模块化 (8) 软件的调试方法主要有:强行排错法、______和原因排除法。 答:回溯法 (9) 数据库系统的三级模式分别为______模式、内部级模式与外部级模式。 答:概念#概念级 (10) 数据字典是各类数据描述的集合...
  • 1.7 函数及模块化编程 13 1.8 常见错误 17 1.9 要点 17 1.10 小结 18 1.11 习题 18 第2章 编程初步 19 2.1 计算机的内存 19 2.2 什么是变量 21 2.3 存储数值的变量 21 2.3.1 整数变量 21 2.3.2 变量的命名...
  • 模块化 C. 自底向上 D. 信息隐蔽 (38) 索引属于(B) A. 模式 B. 内模式 C. 外模式 D. 概念模式 (39) 在关系数据库中,用来表示实体之间联系的是(D) A. 树结构 B. 网结构 C. 线性表 D. 二维表 (40) 将E-R图转换到关系...
  • C语言开始讲,C语言是一种结构化语言,模块化编程,便于程序的调试,依靠非常全面的运算符和多样的数据类型,可以轻易完成各种数据结构的构建,通过指针类型更可对内存直接寻址以及对硬件进行直接操作,因此既能够...
  • 从算法设计到硬线逻辑的实现 复杂数字逻辑系统的VerilogHDL设计技术和方法 夏宇闻 编著 --------------------------------------- ...练习十 通过模块之间的调用实现自顶向下的设计 编者后记 参考资料
  • 面向对象与面向过程

    热门讨论 2018-01-28 11:49:05
    思想方法:模块化 自己的理解:我的目的只是分析出解决问题的步骤,然后用函数把这些步骤一步一步实现,就像工程的流水线一样。 面向过程编程语言:C语言、Fortran语言   面向对象(Object Oriented,OO) 一种对...
  • 当试图通过面向过程解决问题时,我们的关注点在于问题解决的流程,重在这个过程的控制,需要用大量的模块(模块化的思想源自于硬件,在C语言中是函数)将大问题拆解,程序员通过控制模块的执行顺序以解决问题。...
  • 第7章 用函数实现模块化程序设计 7.1 为什么要用函数 7.2 怎样定义函数 7.2.1 为什么要定义函数 7.2.2 定义函数的方法 7.3 调用函数 7.3.1 函数调用的形式 7.3.2 函数调用时的数据传递 7.3.3 函数调用的过程 7.3.4 ...
  • 项目发展而来,目的是打造一个模块化,安全和轻量级的飞控系统。FMT 包括一个主要用C语言实现的嵌入式飞控系统 以及基于 Matlab/Simulink 开发的算法模型库和仿真框架 。 项目源码地址: 为什么使用 FMT FMT 采用...
  • C程序设计(第四版).谭浩强.扫描版

    热门讨论 2011-05-31 10:02:13
    第7章 用函数实现模块化程序设计170 7.1为什么要用函数170 7.2怎样定义函数172 7.2.1为什么要定义函数172 7.2.2定义函数的方法173 7.3调用函数174 7.3.1函数调用的形式174 7.3.2函数调用时的数据传递175 7.3.3函数...
  • C程序设计(第四版)【谭浩强】

    热门讨论 2011-05-25 15:55:43
    第7章 用函数实现模块化程序设计170 7.1为什么要用函数170 7.2怎样定义函数172 7.2.1为什么要定义函数172 7.2.2定义函数的方法173 7.3调用函数174 7.3.1函数调用的形式174 7.3.2函数调用时的数据传递175 7.3.3函数...
  • Tcl_TK编程权威指南pdf

    热门讨论 2011-03-25 09:30:55
    本书共分为55章,依次详细讲述了Tcl基础、Tcl高级特性、TK基础、TK组件、TK详解、C语言编程、各版本之间的差异等方面的知识,并通过大量实例,生动翔实地向读者介绍了Tcl/Tk编程,是读者掌握Tcl/Tt的必备参考书。...
  • ● 编程(用程序语言实现每个模块,简单容易); ● 测试(发现并改正错误,分为模块测试、集成测试和系统联调三级); ● 运行维护(扩充功能、纠错等)。 习题二答案 一、 选择题 1. 需求分析的主要目的是(B C)...
  •  5、黑月的Dll可以使用类似其它语言DLLMAIN入口函数(黑月为“Dll入口函数”),可以通过Dll的模块句柄访问Dll的PE资源、注入进程、多线程应用等等优点。  6、黑月可以突破易语言自身的限制,实现对__cdecl调用...
  • DLL载入后,模块可以通过调用GetProcAddress获取DLL函数的 出口地址,然后就可以通过返回的函数指针调用DLL函数了。如此即可避免导入库文件了 。 27.IP组播有那些好处? 答:Internet上产生的许多新的应用,特别是高...

空空如也

空空如也

1 2 3 4
收藏数 79
精华内容 31
关键字:

c语言模块化通过什么实现

c语言 订阅