3

原创 2013年12月01日 22:21:36
1.C++ STL中判断list为空,size()==0和empty()有什么区别

关于两个的区别,首先size()==0为bool表达式,empty()为函数调用,这一点很明显。查看源代码,

  1. bool empty() const { return _M_node->_M_next == _M_node; }    
  2. size_type size() const {    
  3.   size_type __result = 0;    
  4.   distance(begin(), end(), __result);    
  5.   return __result;    
  6. }  

可以看出empty直接检查标记节点,而size是通过求首尾迭代器的距离来获取元素个数的。


2.STL中的vector\list\deque\set\map的区别

在STL中基本容器有: vector、list、deque、set、map

set 和map都是无序的保存元素,只能通过它提供的接口对里面的元素进行访问

set:集合, 用来判断某一个元素是不是在一个组里面,使用的比较少
map:映射,相当于字典,把一个值映射成另一个值,如果想创建字典的话使用它好了
底层采用的是树型结构,多数使用平衡二叉树实现,查找某一值是常数时间,遍历起来效果也不错, 只是每次插入值的时候,会重新构成底层的平衡二叉树,效率有一定影响.

vector、list、deque、set 是有序容器
1.vector
vector就是动态数组.它也是在堆中分配内存,元素连续存放,有保留内存,如果减少大小后内存也不会释放.如果新值>当前大小时才会再分配内存.

它拥有一段连续的内存空间,并且起始地址不变,因此它能非常好的支持随即存取,即[]操作符,但由于它的内存空间是连续的,所以在中间进行插入和删除会造成内存块的拷贝,另外,当该数组后的内存空间不够时,需要重新申请一块足够大的内存并进行内存的拷贝。这些都大大影响了vector的效率。

对最后元素操作最快(在后面添加删除最快 ), 此时一般不需要移动内存,只有保留内存不够时才需要
对中间和开始处进行添加删除元素操作需要移动内存,如果你的元素是结构或是类,那么移动的同时还会进行构造和析构操作,所以性能不高 (最好将结构或类的指针放入vector中,而不是结构或类本身,这样可以避免移动时的构造与析构)。
访问方面,对任何元素的访问都是O(1),也就是是常数的,所以vector常用来保存需要经常进行随机访问的内容,并且不需要经常对中间元素进行添加删除操作.

相比较可以看到vector的属性与string差不多,同样可以使用capacity看当前保留的内存,使用swap来减少它使用的内存.

总结
需要经常随机访问请用vector

2.list
list就是双向链表,元素也是在堆中存放,每个元素都是放在一块内存中,它的内存空间可以是不连续的,通过指针来进行数据的访问,这个特点使得它的随即存取变的非常没有效率,因此它没有提供[]操作符的重载。但由于链表的特点,它可以以很好的效率支持任意地方的删除和插入

list没有空间预留习惯,所以每分配一个元素都会从内存中分配,每删除一个元素都会释放它占用的内存.

list在哪里添加删除元素性能都很高,不需要移动内存,当然也不需要对每个元素都进行构造与析构了,所以常用来做随机操作容器.
但是访问list里面的元素时就开始和最后访问最快
访问其它元素都是O(n) ,所以如果需要经常随机访问的话,还是使用其它的好

总结
如果你喜欢经常添加删除大对象的话,那么请使用list
要保存的对象不大,构造与析构操作不复杂,那么可以使用vector代替
list<指针>完全是性能最低的做法,这种情况下还是使用vector<指针>好,因为指针没有构造与析构,也不占用很大内存

3.deque
deque是一个双端队列(double-ended queue),也是在堆中保存内容的.它的保存形式如下:
[堆1]
...
[堆2]
...
[堆3]
每个堆保存好几个元素,然后堆和堆之间有指针指向,看起来像是list和vector的结合品.

它支持[]操作符,也就是支持随即存取,可以让你在前面快速地添加删除元素,或是在后面快速地添加删除元素,然后还可以有比较高的随机访问速度,和vector的效率相差无几,它支持在两端的操作:push_back,push_front,pop_back,pop_front等,并且在两端操作上与list的效率也差不多。
在标准库中vector和deque提供几乎相同的接口,在结构上它们的区别主要在于这两种容器在组织内存上不一样,deque是按页或块来分配存储器的,每页包含固定数目的元素.相反vector分配一段连续的内存,vector只是在序列的尾段插入元素时才有效率,而deque的分页组织方式即使在容器的前端也可以提供常数时间的insert和erase操作,而且在体积增长方面也比vector更具有效率

总结:
vector是可以快速地在最后添加删除元素,并可以快速地访问任意元素
list是可以快速地在所有地方添加删除元素,但是只能快速地访问最开始与最后的元素
deque在开始和最后添加元素都一样快,并提供了随机访问方法,像vector一样使用[]访问任意元素,但是随机访问速度比不上vector快,因为它要内部处理堆跳转
deque也有保留空间.另外,由于deque不要求连续空间,所以可以保存的元素比vector更大,这点也要注意一下.还有就是在前面和后面添加元素时都不需要移动其它块的元素,所以性能也很高。

因此在实际使用时,如何选择这三个容器中哪一个,应根据你的需要而定,一般应遵循下面
的原则:
1、如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector
2、如果你需要大量的插入和删除,而不关心随即存取,则应使用list
3、如果你需要随即存取,而且关心两端数据的插入和删除,则应使用deque。



3.fork、vfork、clone区别

在Linux中主要提供了fork、vfork、clone三个进程创建方法。

问题

     在linux源码中这三个调用的执行过程是执行fork(),vfork(),clone()时,通过一个系统调用表映射到sys_fork(),sys_vfork(),sys_clone(),再在这三个函数中去调用do_fork()去做具体的创建进程工作。

fork

fork创建一个进程时,子进程只是完全复制父进程的资源,复制出来的子进程有自己的task_struct结构和pid,但却复制父进程其它所有的资源。例如,要是父进程打开了五个文件,那么子进程也有五个打开的文件,而且这些文件的当前读写指针也停在相同的地方。所以,这一步所做的是复制。这样得到的子进程独立于父进程, 具有良好的并发性,但是二者之间的通讯需要通过专门的通讯机制,如:pipe,共享内存等机制, 另外通过fork创建子进程,需要将上面描述的每种资源都复制一个副本。这样看来,fork是一个开销十分大的系统调用,这些开销并不是所有的情况下都是必须的,比如某进程fork出一个子进程后,其子进程仅仅是为了调用exec执行另一个可执行文件,那么在fork过程中对于虚存空间的复制将是一个多余的过程。但由于现在Linux中是采取了copy-on-write(COW写时复制)技术,为了降低开销,fork最初并不会真的产生两个不同的拷贝,因为在那个时候,大量的数据其实完全是一样的。写时复制是在推迟真正的数据拷贝。若后来确实发生了写入,那意味着parent和child的数据不一致了,于是产生复制动作,每个进程拿到属于自己的那一份,这样就可以降低系统调用的开销。所以有了写时复制后呢,vfork其实现意义就不大了。

fork()调用执行一次返回两个值,对于父进程,fork函数返回子程序的进程号,而对于子程序,fork函数则返回零,这就是一个函数返回两次的本质。

在fork之后,子进程和父进程都会继续执行fork调用之后的指令。子进程是父进程的副本。它将获得父进程的数据空间,堆和栈的副本,这些都是副本,父子进程并不共享这部分的内存。也就是说,子进程对父进程中的同名变量进行修改并不会影响其在父进程中的值。但是父子进程又共享一些东西,简单说来就是程序的正文段。正文段存放着由cpu执行的机器指令,通常是read-only的。


vfork

vfork系统调用不同于fork,用vfork创建的子进程与父进程共享地址空间,也就是说子进程完全运行在父进程的地址空间上,如果这时子进程修改了某个变量,这将影响到父进程。

因此,上面的例子如果改用vfork()的话,那么两次打印a,b的值是相同的,所在地址也是相同的。

但此处有一点要注意的是用vfork()创建的子进程必须显示调用exit()来结束,否则子进程将不能结束,而fork()则不存在这个情况。

Vfork也是在父进程中返回子进程的进程号,在子进程中返回0。

用 vfork创建子进程后,父进程会被阻塞直到子进程调用exec(exec,将一个新的可执行文件载入到地址空间并执行之。)或exit。vfork的好处是在子进程被创建后往往仅仅是为了调用exec执行另一个程序,因为它就不会对父进程的地址空间有任何引用,所以对地址空间的复制是多余的 ,因此通过vfork共享内存可以减少不必要的开销。


clone

    系统调用fork()和vfork()是无参数的,而clone()则带有参数。fork()是全部复制,vfork()是共享内存,而clone()是则可以将父进程资源有选择地复制给子进程,而没有复制的数据结构则通过指针的复制让子进程共享,具体要复制哪些资源给子进程,由参数列表中的clone_flags来决定。另外,clone()返回的是子进程的pid。


4.strcpy和memcpy的区别

strcpy和memcpy都是标准C库函数,它们有下面的特点。
strcpy提供了字符串的复制。即strcpy只用于字符串复制,并且它不仅复制字符串内容之外,还会复制字符串的结束符。

已知strcpy函数的原型是:char* strcpy(char* dest, const char* src);
memcpy提供了一般内存的复制。即memcpy对于需要复制的内容没有限制,因此用途更广。
void *memcpy( void *dest, const void *src, size_t count );

?
char *strcpy(char * dest, const char * src) // 实现src到dest的复制
{
  if ((src == NULL) || (dest == NULL)) //判断参数src和dest的有效性
  {
 
      return NULL;
  }
  char *strdest = dest;        //保存目标字符串的首地址
  while ((*strDest++ = *strSrc++)!='\0');//把src字符串的内容复制到dest下
  return strdest;
}
void *memcpy(void *memTo,const void *memFrom,size_t size)
{
  if((memTo == NULL) || (memFrom == NULL)) //memTo和memFrom必须有效
         return NULL;
  char *tempFrom = (char *)memFrom;            //保存memFrom首地址
  char *tempTo = (char *)memTo;                 //保存memTo首地址     
  while(size -- > 0)                //循环size次,复制memFrom的值到memTo中
         *tempTo++ = *tempFrom++ ; 
  return memTo;
}

strcpy和memcpy主要有以下3方面的区别。
1、复制的内容不同。strcpy只能复制字符串,而memcpy可以复制任意内容,例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度,它遇到被复制字符的串结束符"\0"才结束,所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy,而需要复制其他类型数据时则一般用memcpy


5.求二进制中1的个数

  在《编程之美》一书中有一节提到如何求一个字节的无符号整型变量二进制表示中中1的个数,主要提到了四种方法。下面简单介绍一下:

1.求余法

   在将十进制数转换为二进制数时,采用除2取余法。将每次除2得到的余数保存起来逆序输出便是该十进制整数的二进制表示。因此可以采用这种方法去统计1的个数。

复制代码
int count(unsigned char n)
{
    int sum=0;
    while(n)
    {
        if(n%2==1)
            sum++;
        n/=2;
    }
    return sum;
}
复制代码

2.位运算

   我们知道计算机在处理位运算时速度要快很多,因此可以考虑用位运算的方法来实现。每次先与0X01进行与操作,若非0,则计数器加1,然后向右移1位,循环这个过程。

复制代码
int count(unsigned char n)
{
    int sum=0;
    while(n)
    {
        sum+=n&0x01;
        n>>=1;
    }
    return sum;
}
复制代码

3.快速法

  2中所述方法的循环次数始终为8,有一种方法可以减少这个循环次数。就是采用减1再进行与的运算,这样每进行一次,就会少一个1.

比如: 0010 0110 减1得 0010 0101 &0010 0110等于0010 0100.原因在于比如r1r2...rn,如果最后面位1的一位为rk,则该数减1之后二进制的表示形式中rk肯定为0,但是r(k+1)...rn则全部为1,与原来的数进行与操作不会印象到rk前面的1的个数,因此每进行一次,则可以消去一个二进制1。

复制代码
int count(unsigned char n)
{
    int sum=0;
    while(n)
    {
        n&=(n-1);
        sum++;
    }
    return sum;
}
复制代码

4.查表法。

因此一个字节的无符号整型数据范围就在[0,255]之间,因此可以直接定义一个长度为256的数组table[0-255],把0-255二进制表示中1的1的个数赋给数组的元素,这样直接进行查找。

复制代码
int table[256]={
            0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,               
            1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,                
            1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,               
            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                
            1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,                
            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                
            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                
            3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,               
            1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,                
            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                
            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                
            3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,               
            2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                
            3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,                
            3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,                
            4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, 
            };

int count(unsigned char n)
{
    return table[n];
}
复制代码

以上是四种不同的方法,如果要求一个32位的无符号整数中含有1的个数,则可以根据第四种方法变换一下:

复制代码
int table[256]={            
                0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,                       
                1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,                            
                1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,                          
                2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                            
                1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,                            
                2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                           
                2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                            
                3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,                           
                1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,                           
                2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                            
                2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                            
                3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,                          
                2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,                           
                3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,                           
                3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,                           
                4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,            
             };

int count(unsigned int n)
{
    unsigned char *p=(unsigned char *)&n;
    return table[*p]+table[*(p+1)]+table[*(p+2)]+table[*(p+3)];
}

6.信号量与互斥锁之间的区别
1. 互斥量用于线程的互斥,信号线用于线程的同步。  

这是互斥量和信号量的根本区别,也就是互斥和同步之间的区别。  

互斥:是指某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序,即访问是无序的。  

同步:是指在互斥的基础上(大多数情况),通过其它机制实现访问者对资源的有序访问。在大多数情况下,同步已经实现了互斥,特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源  

2. 互斥量值只能为0/1,信号量值可以为非负整数。  

也就是说,一个互斥量只能用于一个资源的互斥访问,它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是,也可以完成一个资源的互斥访问。  

3. 互斥量的加锁和解锁必须由同一线程分别对应使用,信号量可以由一个线程释放,另一个线程得到。

信号量与线程锁、条件变量相比还有以下几点不同:
1)锁必须是同一个线程获取以及释放,否则会死锁。而条件变量和信号量则不必。
2)信号的递增与减少会被系统自动记住,系统内部有一个计数器实现信号量,不必担心会丢失,而唤醒一个条件变量时,如果没有相应的线程在等待该条件变量,这次唤醒将被丢失。

7.

C/C++ 内存操作越界略述

 

不知大家遇到过没有,有时候程序莫名其妙地出现众多问题,但经常调试来调试去,都不知原因所在,我曾经就被这类问题害得很惨,大部分都是内存操作越界引起的。现在就我知道的总结如下,我将其分为两类:一类是无明显表现的,只会给程序运行带来其妙的错误(1、2、3),一类调试时有明显表现(4、5)。

1、字符串数组定义长度忘记加+1(结束符) 如:

   char str[10];   ::strcpy(str, "0123456789");

  此时将会造成越界,因为strcpy将在str为起始地址的第11个单元写入’0’,这样它将覆盖这个单元的值,对于程序来说,有可能带来灾难性的后果。   但,如果你仅仅作字符串操作,一个一个地存入,此时将不会越界,或者你使用strncpy(str, "0123456789", 10),它也不会越界。不过你得小心,此时将不能使用如:strlen,strcpy等等,它的长度和内容变得完全不确定,如果从str地址起的单元都不为‘’,那么将全看作为它的内容,此时对它的操作将会是多么的恐怖!

2、以指针指向数组来进行操作 指针相对数组的下标操作来说,更灵活、更高效,但常常一不小心它就跑到不知地方的地方去了,在循环批量处理中,多移一位就产生了越界,如果是读还好,但如果是写,这就跟上面出现的问题一样了。

3、将对数据类型的错误操作     short int x;   int y;   x=y 这种操作是不会出错,编译器会解释为 x=(short int)y;丢弃y的高位;但大家看看这个,

   void *p   p=&x;   *(int*)p=y; x只有两个字节的空间,而int需要4个字节的空间, 实际上己出问题了,但你放心,现在的编译器编译后不会引起错误,因为由于内存对齐操作,实际上它分配了4个字节给x,你没有写入到其它数中去,运行会完全正常。

但当你定义的是数组时,那就会有引响了,它会覆盖你后面的数据。 或者你在不同的编程语言中进行数据交换时,而类型与类型宽度不一致就会出问题,如VB中的Integer只有2个字节,而VC中的int是4个,当接口定义不够好时,那就会引发程序崩溃。

4、使用new分配空间,但操作越界

这类越界要容易发现一点,只要你以debug版运行,只要你越界,程序肯定会在delete处停下来。第一次出现此类问题时,真是迷惑不解,我的指针怎么都没变,但就是delete不掉,老报错。由于不知越界会造成此类问题,我一直以为我的电脑哪出毛病了,很正确的事,它就是不对,简直气得我吐血,后来得人指点,才明白,原来这里面还有这个东东!同理malloc,free有此问题。

5、CString在GetBuffer后也容易出现越界

CString确实有很多好用的地方,我最爱它的地方就是作参数,它可以让被调用的函数内分配空间,而在函数外无需对得来的空间进行释放。在CString析构时,它就会帮你释放这块空间。 但在这里面有一个函数你使用不当就会出现越界问题,那就是CString::GetBuffer。通过操作它返回的指针,你便可以直接操作它的缓冲区,这相对通过它的方法来操作内容效率要高出很多,但若你一不小心越界了,那错误也就出来了。不过还好在调试版中,ReleaseBuffer时会报错,若你没有调用ReleaseBuffer,那将在CString析构时报错。

 

上面4、5之所在调试版时会报错,那是由于它们在释放内存时,都调用delete,而delete的实现如下

void __cdecl operator delete(void* p) { #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) _free_dbg(p, _NORMAL_BLOCK); #else free(p); #endif } _free_dbg(p, _NORMAL_BLOCK); 将会作很多方面的检查,如果出错,便会报告出来。而free(p);则只是简间的对内存释放

总结

通过上面几点,相信大家知道如何去避免一些内存越界问题,同时也了解内存越界会引发各类问题,在我们遇到一些希奇古怪的问题时,不防关心一下你的内存操作。

7.C++虚析构函数、纯虚析构函数 

虚析构函数
析构函数的工作方式是:最底层的派生类(most derived class)的析构函数最先被调用,然后调用每一个基类的析构函数。
因为在C++中,当一个派生类对象通过使用一个基类指针删除,而这个基类有一个非虚的析构函数,则结果是未定义的。运行时比较有代表性的后果是对象的派生部分不会被销毁。然而,基类部分很可能已被销毁,这就导致了一个古怪的“部分析构”对象,这是一个泄漏资源。排除这个问题非常简单:给基类一个虚析构函数。于是,删除一个派生类对象的时候就有了你所期望的正确行为。将销毁整个对象,包括全部的派生类部分。
但是,一般如果不做基类的类的析构函数一般不声明为虚函数,因为虚函数的实现要求对象携带额外的信息,这些信息用于在运行时确定该对象应该调用哪一个虚函数。典型情况下,这一信息具有一种被称为 vptr(virtual table pointer,虚函数表指针)的指针的形式。vptr 指向一个被称为 vtbl(virtual table,虚函数表)的函数指针数组,每一个包含虚函数的类都关联到 vtbl。当一个对象调用了虚函数,实际的被调用函数通过下面的步骤确定:找到对象的 vptr 指向的 vtbl,然后在 vtbl 中寻找合适的函数指针。这样子会使类所占用的内存增加。
 
定义纯虚析构函数(pure virtual destructor)
某些类里声明纯虚析构函数很方便。纯虚函数将产生抽象类——不能实例化的类(即不能创建此类型的对象)。有些时候,你想使一个类成为抽象类,但刚好又没有任何纯虚函数。怎么办?因为抽象类是准备被用做基类的,基类必须要有一个虚析构函数,纯虚函数会产生抽象类,所以方法很简单:在想要成为抽象类的类里声明一个纯虚析构函数。
这里是一个例子:
class awov {
public:
virtual ~awov() = 0;      // 声明一个纯虚析构函数
};
这个类有一个纯虚函数,所以它是抽象的,而且它有一个虚析构函数,所以不会产生析构函数问题。但这里还有一件事:必须提供纯虚析构函数的定义:
awov::~awov() {}           // 纯虚析构函数的定义
这个定义是必需的,因为虚析构函数工作的方式是:最底层的派生类的析构函数最先被调用,然后各个基类的析构函数被调用。这就是说,即使是抽象类,编译器也要产生对~awov的调用,所以要保证为它提供函数体。如果不这么做,链接器就会检测出来,最后还是得回去把它添上。

python3+PyQt5 使用数据库表视图

上文提到窗体可以一次性呈现出来自同一记录的各个域,但是对于用户希望能看到多条记录的表来说,就需要使用表格化的视图了。本文通过python3+pyqt5改写实现了python Qt gui 快速变成15...

基于POP3的JAVA邮件接收程序

有发送有接收才显得完整一点。 同样分两部分写: 一:POP3命令介绍(抄的);二:实例。 一:POP3命令介绍 telnet 119.119.119.212 110 -------------...

sublime text 3的c/c++开发环境搭建

本文介绍sublime text 3的c/c++开发环境搭建,包括MinGW的安装,gcc运行c语言,g++运行c++语言,在sublime中运行以及在cmd中运行的方法。另外对于MinGW和gcc,...

CSS3阴影 box-shadow的使用和技巧总结

text-shadow是给文本添加阴影效果,box-shadow是给元素块添加周边阴影效果。随着html5和CSS3的普及,这一特殊效果使用越来越普遍。 基本语法是{box-shadow:[inse...

Python 3基础教程40-队列-Queue

本文来介绍下队列的基本使用,队列是Python线程中最常用的数据交换方法。Queue是queue模块下的对象,Queue是python标准库中的线程安全的队列(FIFO)实现,提供了一个适用于多线程编...

TIFF图像文件格式详解(3)

本文介绍了Baseline TIFF Tag
  • dcraw
  • dcraw
  • 2011年05月25日 20:19
  • 2745

docker应用-3(搭建hadoop以及hbase集群)

要用docker搭建集群,首先需要构造集群所需的docker镜像。构建镜像的一种方式是,利用一个已有的镜像比如简单的linux系统,运行一个容器,在容器中手动的安装集群所需要的软件并进行配置,然后co...

kali4.9 64位系统2017版本安装w3af详细步骤以及遇到的问题解决方法

众所周知,w3af作为web站点的扫描利器,但是不知为何在kali 2017版本里面没有了,所以只能手动安装。下面是详细步骤,期间google解决了很多问题,有些问题困扰了好几天,希望能给以后安装的小...
  • ycl146
  • ycl146
  • 2017年07月12日 21:48
  • 1743

在iBatis中加入c3p0数据库连接池

我看论坛里有两个人写了在iBatis中加入c3p0,我也就不跟着掺合了,做这个的原因是没法用spring,又需要连接池,且对DBCP一直观感不加,没法,只好自己动手了 在iBatis中加入c3p...
  • k_scott
  • k_scott
  • 2013年03月07日 21:56
  • 1040

iQQ 学习笔记3 :编写代码打包Ant脚本

iQQ 学习笔记3说明 :编写代码打包 Ant 脚本 基于iQQ进行二次开发后,为了在生产环境中运行,就需要将代码打包,代码打包包含三部分: 二次开发的程序 iQQ的内核,WebQQ-C...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:3
举报原因:
原因补充:

(最多只允许输入30个字)