精华内容
下载资源
问答
  • 函数库分为静态和动态动态库(格式为libname.so[.主版本号.次版本号.发行号])。在程序编译时并不会被链接到目标代码中,而是在程序运行时才被载入。 静态库是目标文件.a的归档文件(格式为libname.a)。如果在...

    函数库分为静态库和动态库

    动态库(格式为libname.so[.主版本号.次版本号.发行号])。在程序编译时并不会被链接到目标代码中,而是在程序运行时才被载入。

    静态库是目标文件.a的归档文件(格式为libname.a)。如果在编译某个程序时链接静态库,则链接器将会搜索静态库并直接拷贝到该程序的可执行二进制文件到当前文件中;

    1600805-20190410204000789-1010898205.png

    看定义不太好理解,下面举例说明上述概念:

    动态库

    动态库(格式为libname.so[.主版本号.次版本号.发行号])。在程序编译时并不会被链接到目标代码中,而是在程序运行时才被载入。

    $ gcc -fPIC -Wall -c add.c
    $ gcc -shared -o libadd.so add.o
    $ gcc -o main main.c –ladd

    在运行main前,需要注册动态库的路径。将库文件拷贝到/lib或者/usr/lib下(系统默认搜索库路径)。

    $ cp libadd.so /lib        //通常采用的方法, cp lib*.so /lib
    $ ./main

    实例测试:

    add.c

    int add(int a, int b){
        return a + b;
    }

    main.c

    #include <stdio.h>
    int add(int a, int b);
    int main()
    {
        int res = add(3, 4);
        printf("res = %d\n", res);
        return 0;
    }

    这里我们要将add.c生成动态库使得main.c能编译运行。

    gcc -fPIC -Wall -c add.c
    gcc -shared add.o -o libadd.so
    sudo cp libadd.so /usr/lib
    gcc main.c -ladd

    执行时将动态库(libadd.so)与a.out同时加载到代码段才能运行。当多个代码段需要用到一个libXXX时,并不会生成多个libXXX放入代码段,而是通过共享库。

    当动态库升级时,以格式为libname.so[.主版本号.次版本号.发行号]命名,如现在将原来的libadd.so修改为libadd.so.1,那怎么让原来main.c文件中的add函数还能实现呢?——软链接


    先穿插一个概念:

    软链接

    命令:$ ln -s filename1 filename2

    功能: filename2 -> filename1

    可以看到当链接建立时,file1 -> file,file1的大小为4B,file的大小为739B。可以用过 ls -lh查看链接。

    1600805-20190410204034100-1601661152.png

    软链接存储是路径,相当于file1是file的一个快捷方式,所以在查看file1的时候也是显示file的内容。

    1600805-20190410204036177-264126429.png


    回到原来的问题,现在将原来的libadd.so修改为libadd.so.1,只要将libadd.so.1与libadd.so软链接即可。

    sudo ln -s libadd.so.1 libadd.so
    静态库
    gcc -c add.c                //编译add.c生成add.o
    ar crsv libadd.a add.o       //对目标文件*.o进行归档,生成lib*.a,将库文件libadd.a拷贝到/lib或者/usr/lib下(系统默认搜索库路径)
    gcc -o main main.c -ladd     //-ladd表示链接库文件libadd.a/.so
    ./main

    还是用上面同一个例子做测试:
    1600805-20190410204056338-178862079.png

    main.c

    #include <stdio.h>
    
    int add(int, int);
    
    int main()
    {
        int j = add(3, 4);
        printf("%d\n", j);
        return 0;
    }

    静态库是目标文件.a的归档文件(格式为libname.a)。如果在编译某个程序时链接静态库,则链接器将会搜索静态库并直接拷贝到该程序的可执行二进制文件到当前文件中;

    所以当我们在删除库文件中libadd.a后还是可以编译执行main.c!


    静态库与动态库的比较:

    ​ 动态库只在执行时才被链接使用,不是直接编译为可执行文件,并且一个动态库可以被多个程序使用故

    可称为共享库

    ​ 静态库将会整合到程序中,在程序执行时不用加载静态库。 因此,静态库会使你的程序臃肿并且难以升

    级,但比较容易部署。而动态库会使你的程序轻便易于升级但难以部署。

      二者的不同点在于代码被载入的时刻不同

    • 静态库在程序编译时会被连接到目标代码中,程序运行时将不再需要该静态库,因此体积较大
    • 动态库在程序编译时并不会被连接到目标代码中,而是在程序运行是才被载入,因此在程序运行时还需要动态库存在,因此代码体积较小

    转载于:https://www.cnblogs.com/Mered1th/p/10685962.html

    展开全文
  • 接上文【linux系统下的“静态和动态库”专题之一:库的概念规则】所述,我们通常把一些公用函数制作成函数库,供其它程序使用。函数库分为静态和动态库两种。 – 静态库在程序编译时会被连接到目标代码中,...

    接上文【linux系统下的“静态库和动态库”专题之一:库的概念和规则】所述,我们通常把一些公用函数制作成函数库,供其它程序使用。函数库分为静态库和动态库两种。

    – 静态库在程序编译时会被连接到目标代码中,程序运行时将不再需要该静态库。
    – 动态库在程序编译时并不会被连接到目标代码中,而是在程序运行是才被载入,因此在程序运行时还需要动态库存在。

    本文主要通过举例来说明在Linux中如何创建静态库和动态库,以及使用它们。

    在创建函数库前,我们先来准备举例用的源程序,并将函数库的源程序编译成.o文件。

    第1步:编辑源程序代码

    本实例中需要用到3个源程序:hello.h、hello.c和main.c。

    – hello.h(见程序1)为该函数库的头文件。
    – hello.c(见程序2)是函数库的源程序,其中包含公用函数hello,该函数将在屏幕上输出”Hello XXX!”。
    – main.c(见程序3)为测试库文件的主程序,在主程序中调用了公用函数hello。

    下面附上全部的源代码内容,便于大家自己学习测试。

    【程序1: hello.h】

    #ifndef HELLO_H
    #define HELLO_H
    
    void hello(const char *name);
    
    #endif //HELLO_H

    【程序2: hello.c】

    #include "stdio.h"
    
    void hello(const char *name)
    {
      printf("Hello %s!\n", name);
    }

    【程序3: main.c】

    #include "hello.h"
    
    int main()
    {
      hello("everyone");
      return 0;
    }

    第2步:将hello.c编译成.o文件

    无论静态库,还是动态库,都是由.o文件创建的。因此,我们必须将源程序hello.c通过gcc先编译成.o文件。

    在系统提示符下键入以下命令得到hello.o文件。

    # gcc -c hello.c 

    注1:本文不介绍各命令使用和其参数功能,若希望详细了解它们,请参考其他文档。
    注2:首字符”#”是系统提示符,不需要键入,下文相同。

    我们运行ls命令看看是否生存了hello.o文件。

    # ls 
    hello.c hello.h hello.o main.c 

    在ls命令结果中,我们看到了hello.o文件,本步操作完成。
    下面我们先来看看如何创建静态库,以及使用它。

    第3步:由.o文件创建静态库

    静态库文件名的命名规范是以lib为前缀,紧接着跟静态库名,扩展名为.a。
    例如:我们将创建的静态库名为myhello,则静态库文件名就是libmyhello.a。

    创建静态库用ar命令。

    在系统提示符下键入以下命令将创建静态库文件libmyhello.a。

    # ar cr libmyhello.a hello.o

    我们同样运行ls命令查看结果:

    # ls 
    hello.c hello.h hello.o libmyhello.a main.c

    可以看到静态库libmyhello.a已经创建成功。

    第4步:在程序中使用静态库

    静态库制作完了,如何使用它内部的函数呢?

    很简单,只需要在使用到这些公用函数的源程序中包含这些公用函数的原型声明,然后在用gcc命令生成目标文件时指明静态库名,gcc将会从静态库中将公用函数连接到目标文件中。

    注意,gcc会在静态库名前加上前缀lib,然后追加扩展名.a得到的静态库文件名来查找静态库文件。

    在程序3(main.c)中,我们包含了静态库的头文件hello.h,然后在主程序main中直接调用公用函数hello。下面生成目标程序hello,然后运行hello程序看看结果如何。

    # gcc -o hello main.c -L. -lmyhello 
    # ./hello 
    Hello everyone! 

    可以看到,程序运行成功了!

    接下来,我们删除静态库文件,试试公用函数hello是否真的连接到目标文件 hello中了。

    # rm libmyhello.a 
    rm: remove regular file `libmyhello.a'? y 
    # ./hello 
    Hello everyone! 

    程序照常运行,说明静态库中的公用函数已经连接到目标文件中了。

    OK。静态库的使用介绍到此为止。我们接下来看下如何在Linux中创建动态库。我们还是从.o文件开始。

    第5步:由.o文件创建动态库文件

    动态库文件名命名规范和静态库文件名命名规范类似,也是在动态库名增加前缀lib,但其文件扩展名为.so。
    例如:我们将创建的动态库名为myhello,则动态库文件名就是libmyhello.so。

    要注意的是,创建静态库不再使用ar命令,而是gcc命令。

    在系统提示符下键入以下命令得到动态库文件libmyhello.so。

    # gcc -shared -fPCI -o libmyhello.so hello.o

    我们照样使用ls命令看看动态库文件是否生成。

    # ls 
    hello.c hello.h hello.o libmyhello.so main.c 

    可以看到,动态库已经生成成功了。

    第6步:在程序中使用动态库

    在程序中使用动态库和使用静态库完全一样,也是在使用到这些公用函数的源程序中包含这些公用函数的原型声明,然后在用gcc命令生成目标文件时指明动态库名进行编译。

    我们先运行gcc命令生成目标文件,再运行它看看结果。

    # gcc -o hello main.c -L. -lmyhello 
    # ./hello 
    ./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory 

    哦!出错了。

    看看错误提示,原来是找不到动态库文件libmyhello.so。
    这里要说明一下,linux 系统下有一个潜规则,程序在运行时,会自动从/usr/lib/lib等目录中查找需要的动态库文件。若找到,则载入动态库,启动程序开始运行。若找不到,则提示类似上述错误而终止程序运行。

    于是,我们将文件libmyhello.so复制到目录/usr/lib中,再试试。

    # mv libmyhello.so /usr/lib 
    # ./hello 
    ./hello: error while loading shared libraries: /usr/lib/libhello.so: cannot restore segment prot after reloc: Permission denied

    仍然存在问题!
    百度一下,可以看到,这个问题是由于SELinux引起。具体原因在此就不做详细分析,如果有兴趣可以自己百度。这里只给出参考解决方案:

    方案一:

    编辑/etc/selinux/config,找到这段:

    # This file controls the state of SELinux on the system.
    # SELINUX= can take one of these three values:
    # enforcing - SELinux security policy is enforced.
    # permissive - SELinux prints warnings instead of enforcing.
    # disabled - SELinux is fully disabled.
    SELINUX=enforcing 

    SELINUX=enforcing注释掉:然后新加一行为:

    #SELINUX=enforcing
    SELINUX=disabled

    保存,关闭。

    编辑/etc/sysconfig/selinux,找到:

    # This file controls the state of SELinux on the system.
    # SELINUX= can take one of these three values:
    # enforcing - SELinux security policy is enforced.
    # permissive - SELinux prints warnings instead of enforcing.
    # disabled - SELinux is fully disabled.
    SELINUX=enforcing

    同样把SELINUX=enforcing注释掉:然后新加一行为:

    #SELINUX=enforcing
    SELINUX=disabled

    保存,关闭。

    方案二:

    # chcon -t texrel_shlib_t /usr/lib/libhello.so

    以上两个方案,任选一个均可。但是不保证能兼容所有系统,所以如果有同学执行了方案一,仍然会出错,则继续执行方案二。这样应该能解决了。

    解决完后,重新运行程序:

    # ./hello
    Hello everyone! 

    成功了。这也进一步说明了动态库在程序运行时是需要的。

    第7步:静态库和动态库并存的情况

    我们回过头看看,发现使用静态库和使用动态库编译成目标程序使用的gcc命令完全一样,那当静态库和动态库同名时,gcc命令会使用哪个库文件呢?抱着对问题必究到底的心情,来试试看。

    先把所有除.c和.h外的文件全部删除,恢复成我们刚刚编辑完举例程序的状态。

    # rm -f hello hello.o /usr/lib/libmyhello.so 
    # ls 
    hello.c hello.h main.c 

    再来创建静态库文件libmyhello.a和动态库文件libmyhello.so。

    # gcc -c hello.c 
    # ar cr libmyhello.a hello.o 
    # gcc -shared -fPCI -o libmyhello.so hello.o 
    # ls 
    hello.c hello.h hello.o libmyhello.a libmyhello.so main.c

    通过上述最后一条ls命令,可以发现静态库文件libmyhello.a和动态库文件libmyhello.so都已经生成,并都在当前目录中。然后,我们运行gcc命令来使用函数库myhello生成目标文件hello,并运行程序 hello。

    # gcc -o hello main.c -L. -lmyhello 
    # ./hello 
    ./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory

    从程序hello运行的结果中很容易知道,当静态库和动态库同名时, gcc命令将优先使用动态库。

    OK。今天关于如何在linux系统下生成和使用静态库以及动态库的话题,就先聊到这里。有任何问题,欢迎大家随时留言和联系。

    展开全文
  •   通常把一些公用函数制作成函数库,供其它程序使用。函数库分为静态和动态库两种...本文主要通过举例来说明在Linux中如何创建静态和动态库,以及使用它们。 自定义库函数源文件add.c 代码清单 int add(int ...

      通常把一些公用函数制作成函数库,供其它程序使用。函数库分为静态库和动态库两种。静态库在程序编译时会被连接到目标代码中,程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中,而是在程序运行是才被载入,因此在程序运行时还需要动态库存在。本文主要通过举例来说明在Linux中如何创建静态库和动态库,以及使用它们。

    1. 自定义库函数源文件add.c 代码清单
    int add(int a,int b)
    {
        int c=0;
        c = a + b;
        return c;
    }
    
    1. 主程序源文件main.c代码如下
    #include <stdio.h>
    int add(int a,int b);
    
    int main(void)
    {
        int i = 0;
        for(i=0; i < 20; i++) {
            int sum = add(110,i);
            printf("sum:%d\n",sum);
        }
        return 0;
    }
    
    1. 编译生成静态库文件

    编译生成目标文件
    [csy@local libtest]$ gcc -c add.c
    把add.o编译成静态链接库.a:
    [csy@local libtest]arcrsvlibadd.aadd.o//.olib.a,libadd.olibadd.a:[csy@locallibtest]ar -crsv libadd.a add.o //对目标文件*.o进行归档,生成lib*.a,此处lib要写 对目标文件add.o进行归档,生成libadd.a后文件列表: [csy@local libtest]ls
    add.c add.o libadd.a main.c

    静态库使用

    方法一:当源文件使用
    简单直接使用方法,把库存文件当成源文件使用:
    gcc hello.c libadd.a -o haha

    方法二:标准用法使用gcc 选项指定
    在库文件的搜索路径中添加当前路径:
    -ladd表示链接库文件libadd.a或libadd.so
    -I./表示包含在当前目录中的头文件,如果代码没有使用到自定义的头文件不需要-I指定
    [csy@local libtest]$ gcc -o main main.c -L./ -ladd -I.
    [csy@local libtest]$ ls
    add.c add.o libadd.a main main.c
    [csy@local libtest]$ ./main
    sum:110

    sum:129

    方法三:把.a存放在默认路径中,不需要指明库路径
    [root@zhifachen libtest]#cp libadd.a /lib
    /lib目录是编译器默认搜索库文件的路径之一,不需要指明这个路径它也能找到libadd
    [root@zhifachen libtest]#gcc -o main hello.c -ladd
    [root@zhifachen libtest]#./main

    动态库存创建及使用

    动态库(格式为libname.so[.主版本号.次版本号.发行号])。在程序编译时并不会被链接到目标代码中,而是在程序运行时才被载入。

    动态库创建

    把上一个例子代码制作成动态库:
    [csy@local libtest]$ gcc -fPIC -Wall -c add.c
    [csy@local libtest]$ gcc -shared -o libadd.so add.o

    也可以两步合成一步完成:
    [csy@local libtest]$ gcc -fPIC -Wall -shared add.c -o libadd.so

    动态库使用
    1. 使用动态库编译

    2. 方法一:当源文件使用
      简单直接使用方法,把库存文件当成源文件使用:
      [csy@local libtest]$ gcc hello.c libadd.so -o main
      方法二:标准方法,使用gcc选项指定库路径,库名
      [csy@local libtest]$ gcc -o main hello.c -L./ -ladd

    3. 测试可执行程序:将运行失败
      [csy@local libtest]$ ./main
      ./main: error while loading shared libraries: libadd.so: cannot open shared object file: No such file or directory
      测试失败,错误,提示找不到 libadd.so , 这就是动态库和静态库的一个区别。动态库链接不是把需要的代码复制到最终的可执行程序中,而是运行时候动态加载调用。所以还需要告诉系统在什么位置可以找到库,如何指定库路径在下面一小节中介绍。

    注册动态库的路径.

    1. 方法1:将库文件拷贝到/lib或者/usr/lib下(系统默认搜索库路径)
      [csy@local libtest]$ cp libadd.so /lib
      [csy@local libtest]$ ./main
      sum:110
      ……
      sum:127
      sum:128
      sum:129
      [csy@local libtest]$

    测试过程:

    [root@local libtest]# ./main.exe 
    ./main.exe: error while loading shared libraries: libadd.so: cannot open shared object file: No such file or directory
    [root@local libtest]# ls
    add.c  add.o  libadd.a  libadd.so  main  main.c  main.exe
    [root@local libtest]# cp libadd.so /lib/
    [root@local libtest]# ./main
    
    1. 方法2:修改 LD_LIBRARY_PATH环境变量
      先删除方法复制的动态库文件:
      [csy@local libtest]$ rm /lib/libadd.so
      rm:是否删除普通文件 “/lib/libadd.so”?y
      运行,方便后面比较:
      [csy@local libtest]$ ./main
      ./main: error while loading shared libraries: libadd.so: cannot open shared object file: No such file or directory
      测试失败,找不到库。

    学习export 命令:
    export 是导出环境变量命令(环境变量名可以系统中预定义,也可以自定义)
    [csy@local libtest]$ export Test_Export=123
    [csy@local libtest]$ echo $Test_Export
    123

    上面的Test_Export是自定义的变量名,Linux系统中shell引用变量是 $变量名
    注意:export 命令在终端中执行 时候,只在当前终端有效,新开的终端是无效的。

    临时设置动态库环境变量:
    设置系统预定义的环境变量 LD_LIBRARY_PATH ,这个变量值作用是告诉系统还可以到哪里去找动态库文件。
    [csy@local libtest]$ export LD_LIBRARY_PATH=PWD[csy@locallibtest]PWD [csy@local libtest] ./main
    测试过程截图:
    在这里插入图片描述
    3. 方法3:修改 /etc/ld.so.conf
    这个文件记录了动态链接库的路径。默认情况下,编译器只会使用 /lib和 /usr/lib这两个目录下的库文件。
    把libadd.so所在路径添加到这个文件中后,再以 root 的身份运行ldconfig 命令才会生效。
    为了测试这个方法,关闭前面打开的终端,因为方法2使用临时环境变量,但是只在当前终端有效。打开新终端,再次运行./main将失败,如下:

    查看当前路径,后面要把这个路径添加到 /etc/ld.so.conf 文件中。
    [csy@local libtest]$ pwd

    [csy@local libtest]$ vim /etc/ld.so.conf
    修改 /etc/ld.so.conf ,如下:
    include ld.so.conf.d/*.conf
    /root/work/test/libtest

    修改好后,保存,运行./main测试:
    [csy@local libtest]$ ./main
    ./main: error while loading shared libraries: libadd.so: cannot open shared object file: No such file or directory
    还是会失败,因为还没有运行 ldconfig命令。
    [csy@local libtest]$ ldconfig
    [csy@local libtest]$ ./main
    测试过程:
    ./main.exe: error while loading shared libraries: libadd.so: cannot open shared object file: No such file or directory
    [root@local libtest]# Idconfig
    bash: Idconfig: command not found
    [root@local libtest]# ldconfig
    [root@local libtest]# ./main.exe
    sum:110
    sum:111

    展开全文
  • AOP实现的关键在于AOP框架自动创建的AOP代理,AOP代理主要分为静态代理和动态代理,静态代理的代表为AspectJ;而动态代理则以Spring AOP为代表。 何为切面? 一个业务没有任何耦合相关的代码段,诸如:调用日志,...
  • Web开发 -- 静态页面与动态页面

    千次阅读 2017-09-24 13:15:56
    在网页开发过程中,有静态页面和动态页面之分。虽然之前有过一定的了解,但是实际上并不系统。因此,本篇博客将对静态页面以及动态页面的本质进行分析。静态页面静态页面(Static Web Page)是一种当用户发出请求访问...

    在网页开发过程中,有静态页面和动态页面之分。虽然之前有过一定的了解,但是实际上并不系统。因此,本篇博客将对静态页面以及动态页面的本质进行分析。

    静态页面

    静态页面(Static Web Page)是一种当用户发出请求访问数据库的数据的时候,不做数据库信息的修改,然后返回必要的内容。举例来说,就是当我们登录到一个网站之后,在登录之前显示的内容。对于任何一台电脑,其信息都是相同的。一般而言,其是.html的文件类型。

    关于其直观的认识,可以看下面这幅图:

    这里写图片描述

    其具有的优点与缺点:

    Advantages of a static website

    Provide improved security over dynamic websites[1]
    Improved performance for end users compared to dynamic websites[2]
    Less or no dependencies on systems such as databases or other application servers

    Disadvantages of a static website

    Dynamic functionality has to be added separately

    动态页面

    动态页面也就是对于用户传入的数据,数据库会对其进行处理,然后将处理之后的结果传递回来的过程。由于其涉及到与底层数据的交互,因此相对而言可以个性化地进行功能实现,同时对功能有更好的更新操作。

    动态页面直观如图所示:

    这里写图片描述

    总结

    该博客对于静态页面以及动态页面实际上也仅仅是概念上粗浅的认识,但是关于其两者本质的区别以及优缺点应该是表述得比较清楚了。关于其从实现角度的特点以及差异将在之后进行归纳总结。

    参考资料

    1. Static Web Page from Wikipedia
    2. Dynamic Web Page from Wikipedia
    展开全文
  • 我们把js内部类分为两类(动态类,静态类)。 (1)动态类:在引用其属性方法的时候:① var 对象实例名=new 类();② 对象实例名.方法(或属性) (2)静态类:在引用其属性方法的时候:态类.方法(或属性) (Math) ...
  • 静态投资回收期 概念:不考虑货币时间价值因素,通常以年为单位 公式: 举例:   动态投资回收期 概念:考虑货币时间价值因素,通常以年为单位 公式: 举例:   ...
  • Linux系统中关于gcc的基础练习。 一.用 gcc 生成 .a 静态库... 本部分主要通过举例来说明在 Linux 中如何创建静态和动态库,以及使用它们。 在创建函数库前,我们先来准备举例用的源程序,并将函数库的源程序编译成.o
  • 全局区(静态区):全局变量和静态变量的存储是放在一块的,初始化的全局变量和未初始化的静态变量在相邻的另一块儿区域,该区域在程序结束后有操作系统释放,字符串常量和其它常量的存储在常量区,...
  • 按是否需要执行被测软件的角度可分为静态测试和动态测试前者不利用计算机运 行待测程序而应用其他手段实现测试目的 如代码审核 我认为主要是让测试人员对编译 器发现不了的潜在错误进行分析如无效的
  • 为什么需要动态内存分配解决方法:动态内存分配动态申请内存操作符 newnew 类型名T(初始化参数列表)释放内存操作符deletedelete 指针名p注意问题内存泄露举例申请释放动态数组动态创建多维数组 何为静态内存分配?...
  • 查询功能也是系统的核心之一,在系统中即有单条件查询多条件查询,也有精确查询模糊查询,系统不仅有静态的条件查询,也有动态生成的条件查询,其目的都是为了方便用户使用。系统有完整的用户添加、删除密码...
  • 专题--动态内存分配

    2021-04-17 18:35:51
    为什么需要动态分配内存动态内存分配举例_动态数组的构造静态内存和动态内存的比较跨函数使用内存的问题 可参考视频《郝斌C语言自学教程》动态内存分配部分 1. 传统数组的缺点 1. 数组长度必须首先指定,且只能是常...
  • YidaCMS免费开源网站管理系统是基于微软的WINDOWSIIS平台,采用ASP语言ACCESSMSSQL双数据库开发完成。 YidaCMS免费开源网站管理系统整体系统采用强大的HTML引擎,模板设计程序语言完全分开,这会让您在设计模板...
  • Java——数组(概念理解+应用举例

    千次阅读 2020-06-04 13:24:12
    数组是一个非常重要的概念,我们经常使用的数组,在这里C语言基本上是一样的,无非是“一维数组”“二维数组”,那么对数组的初始化定义有两种方法,一个是“静态初始化”,另一个自然就是“动态初始化”。...
  • 数据库系统导论(第7版)

    热门讨论 2011-09-19 10:23:22
    8.7 静态约束和动态约束 184 8.8 码 185 8.9 SQL对完整性的支持 191 8.10 小结 194 练习 194 参考文献简介 196 部分练习答案 201 第9章 视图 209 9.1 引言 209 9.2 视图的用途 211 9.3 视图检索 213 9.4 视图更新 ...
  • 动态内存分配 传统数组的缺点: 1数组长度必须事先制定,且只能是长整数不能是变量 2传统形式定义的数组该数组的内存程序无法手动释放 3数组一旦定义,系统就会为...静态内存分配和动态内存分配 跨函数使用内存的问题
  • AIS数据解析AIS电文种类暗码数据格式AIS数据部分字符编码比特值与ASCII码的对照表动态信息的格式表ROT参数说明静态信息的格式表船舶货物类型报告位置参考点船舶尺寸B类AIS信息的解码过程举例VDM消息类型补充 ...
  • 8.7 静态约束和动态约束 184 8.8 码 185 8.9 SQL对完整性的支持 191 8.10 小结 194 练习 194 参考文献简介 196 部分练习答案 201 第9章 视图 209 9.1 引言 209 9.2 视图的用途 211 9.3 视图检索 213 9.4 视图更新 ...
  • 4.2.2 典型文件举例 4.3 ClassWizard(类向导) 4.3.1 ClassWizard的功能 4.3.2 ClassWizard的简单应用 4.3.3 为项目添加新类 4.3.4 手工添加消息处理函数 第5章 文档与视图 5.1 Document与View概述 5.2 Document与...
  • 8.7 静态约束和动态约束 184 8.8 码 185 8.9 SQL对完整性的支持 191 8.10 小结 194 练习 194 参考文献简介 196 部分练习答案 201 第9章 视图 209 9.1 引言 209 9.2 视图的用途 211 9.3 视图检索 213 9.4 视图更新 ...
  • 8.7 静态约束和动态约束 184 8.8 码 185 8.9 SQL对完整性的支持 191 8.10 小结 194 练习 194 参考文献简介 196 部分练习答案 201 第9章 视图 209 9.1 引言 209 9.2 视图的用途 211 9.3 视图检索 213 9.4 视图更新 ...
  • 4.2.2 典型文件举例 4.3 ClassWizard(类向导) 4.3.1 ClassWizard的功能 4.3.2 ClassWizard的简单应用 4.3.3 为项目添加新类 4.3.4 手工添加消息处理函数 第5章 文档与视图 5.1 Document与View概述 5.2 Document与...
  •   • 安全属性,包括所有权凭据特权;   • 程序代码的一个或多个执行线程;   • 进程状态。 程序: 二进制文件,是静态的   例如/usr/bin/passwd ,/usr/sbin/useradd 进程: 是程序运行的过程, 动态,有...
  • 1. 静态初始化:如果互斥锁 mutex 是静态分配的(定义在全局,或加了static关键字修饰),可以直接使用宏进行初始化。e.g. pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER; 2. 动态初始化:局部变量应采用动态...
  • 举例说明。 如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。 当应用程序在对象上调用了一个需要...
  • 变量关键字

    2021-04-10 11:40:39
    静态变量与动态变量的基本概念 静态变量:指的是在编译时(compiling-time)变量的地址大小都已经确定下来的变量 动态变量:指的是在运行时(run-time)变量的地址大小才开始确定。这个确定不是持续长久的,当程序...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 196
精华内容 78
关键字:

动态系统和静态系统举例