背景：

在工作中遇到按位或组合权限串。一直不是特别明白。今天终于花了半个下午的时间搞明白其中的道理。
首先每一个权限数都是2的N次方数
如：

k1=2 ; //添加
k2=4 ; //删除
k3=8; //修改
...

如此定义功能权限数，当需要组合权限时，就需要对各个所拥有的权限数按位或了。
如：

purview = k2|k3; // 赋给添加和删除权限

当需要判断在权限串中是否拥有某一权限时，就需要进行按位与。
如：

 if（(purview & k1) >0）//判断此权限串是否拥有添加权限，结果>0 则进入if语句代码块中

  {

         ....

  } 

说到这里肯定会有疑问了，别急我来细细讲解。

第一，2的8位二进制值为00000010

4的8位二进制值为00000100
8的8位二进制值为00001000

第二，当对8和4进行按位或操作后，结果为：

4|8 = 12
00000100 |00001000 = 00001100

为什么会是这样呢？在进行按位或操作时：
00000001|00000001=00000001；
00000001|00000000=00000001；
00000000|00000000=00000000
也就是说除了0|0结果是0外，其它运算结果的都是1
所以：
00000100 |00001000 = 00001100
也就说上面的 purview = k2|k3 的二进制值结果是：
purview =00000100 |00001000 =00001100了

第三，当对8和4进行按位与操作后，结果为：

4&8=0
00000100 &00001000 = 00000000

同样为什么会是这样呢？在进行按位与操作时：
00000001&00000001=00000001；
00000001&00000000=00000000；
00000000&00000000=00000000；
也就是说除了1&1结果是1外，其它运算结果的都是0
所以：
00000100 &00001000 = 00000000

上面的if（(purview & k1) >0）的结果就是 00001100&00000010 =00000000 也就是(0>0)=false
同样if（(purview & k2) >0）的结果就是 00001100&00000100 =00000100=4=k2 也就是 (4>0)=true

这样我们就理解组合权限串和判断权限的原理了，说白了就是对2N次方数的按位与和按位或。

应用场景

比如在做一些社交类的需求中，经常会遇到那种点赞，推荐，明天再加个置顶的，简直没完没了，总不能今天加个字段，明天再加个吧；这时候位运算就派上用用场了，每个属性一个2N次方数，枚举定义下去，这样一个字段即可解决，新来一个属性再加个枚举即可。

核心代码

public class Test
{
    /// <summary>
    /// 计算权限总和
    /// </summary>
    /// <param name="OldStatus">数据库现有权限总和</param>
    /// <param name="Action">取消或设置操作（0取消，1设置）</param>
    /// <param name="StatusVal">设置操作对应的状态值</param>
    /// <returns></returns>
    public static int ReturnStatusTotal(int OldStatus, int Action, int StatusVal)
    {
        int NewStatus = OldStatus;
        if (Action == 1)
        {
            //判断此权限串是否拥有相应操作,不包括时加入权限
            if ((OldStatus & StatusVal) <= 0)
            {
                NewStatus = OldStatus | StatusVal;
            }
        }
        else
        {
            //判断此权限串是否拥有相应操作,有权限时移除权限
            if ((OldStatus & StatusVal) > 0)
            {
                NewStatus = OldStatus & ~StatusVal;
            }
        }

        return NewStatus;
    }
}

NewStatus = CommonUtilities.ReturnStatusTotal(OldStatus, objRequest.Action, (int)StatusEnum.ZhiDing);

转自： 【程序员编程日记】公众号

内核：在一些系统中，当系统调用发生时，操作系统或者操作系统内核会编程应用程序内存的一部分。

栈：栈中包含活动记录，其中包含当前活动函数调用的返回地址和局部变量等信息。

共享库：为了动态链接共享库文件而创建的一个内存片段

堆内存：被用作堆内存来使用和分配的一块内存空间。如果运行时需要一些可变大小的小内存块，那么这些内存就是从这个区域中分配的

未初始化的数据： 没有初始化的全局变量被放在固定地址中。通常，这段区域都会被初始化为0。

初始化的数据： 任何被赋予了初始值的数据都被组织在内存中的一段连续的区域内，因此他们就能够与程序页一同被有效地载入

程序页：构成应用程序的机器代码指令就是程序页。当有硬件支持时，程序页通常是只读的，这样就可以防止程序意外的重写其自身指令区域。

第0页：通常，一个以地址0为开始的内存片段会被保留下来被设置为不可读区域，他可以用来捕捉一种常见的错误，这种错误就是使用一个NULL指针访问数据。

第一部分 C++内存地址分配简介

1 内存地址是从高地址到低地址进行分配的：

int i=1;
int j=1;
cout
2 函数参数列表的存放方式是，先对最右边的形参分配地址，后对最左边的形参分配地址。

3 Little-endian模式的CPU对操作数的存放方式是从低字节到高字节的

0x1234的存放方式入下：

0X4000 0x34

0X4001 0x12

4 Big-endian模式的CPU对操作数的存放方式是从高字节到低字节的

0x1234的存放方式入下：

0x4000 0x12

0x4001 0x34

5 联合体union的存放顺序是所有成员都从低地址开始存放。

6 一个变量的地址是由它所占内存空间中的最低位地址表示的。

0X4000 0x34

0X4001 0x12

0x1234 的地址位0x4000

7 堆栈的分配方式是从高内存地址向低内存地址分配的。

int ivar=0;

int iarray[2]={11, 22};

注意iarray[2]越界使用，比如对其赋值

iarray[2]=0;

那么则同时对ivar赋值为0，可能产生死循环，因为它们的地址相同，即&ivar等于&iarray[2]。

第二部分 C/C++内存区划分

一 在C中分为这几个存储区

1.栈 由编译器自动分配释放；

2.堆 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收；

3.全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 程序结束释放；

4.另外还有一个专门放常量的地方。 程序结束释放。

在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的”adgfdf”这样的字符串存放在常量区。比如：

int  a = 0; //全局初始化区  
char *p1; //全局未初始化区  
void main()  
{       
int b;                   //栈       
char s[] = "abc"; //栈       
char *p2;         //栈       
char *p3 = "123456";       //123456{post.content}在常量区，p3在栈上       
static int c = 0;          //全局（静态）初始化区       
p1 = (char *)malloc(10);   //分配得来得10字节的区域在堆区       
p2 = (char *)malloc(20);   //分配得来得20字节的区域在堆区       
strcpy(p1, "123456");      
//123456{post.content}放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块  
}  

二.在C++中，内存分成5个区

他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区

1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

2.堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

3.自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）。

在bbs上，堆与栈的区分问题，似乎是一个永恒的话题。 　　

首先，我们举一个例子：

void f()
{
int* p=new int[5];
}
这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？它分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。

在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：

00401028 push 14h
0040102A call operator new (00401060)
0040102F add esp,4
00401032 mov dword ptr [ebp-8],eax 这里写代码片
00401035 mov eax,dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4],eax
这里，我们为了简单并没有释放内存，那么该怎么去释放呢?是delete p么?错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。

好了，我们回到我们的主题：堆和栈究竟有什么区别?

主要的区别由以下几点：

1、管理方式不同;

2、空间大小不同;

3、能否产生碎片不同;

4、生长方向不同;

5、分配方式不同;

6、分配效率不同;

管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制;对于堆来说，释放工作由程序员控制，容易产生memory leak。

空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M(好像是，记不清楚了)。当然，我们可以修改：

打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。

注意：Reserve最小值为4Byte;commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。

碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在它弹出之前，在它上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。

生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向;对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。

分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，它的动态分配是由编译器进行释放，不需要我们手工实现。

分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高(我的注释:关于EBP寄存器请参考另一篇文章)。

堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法

(具体的算法可以参考数据结构/操作系统)在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间

(可能是由于内存碎片太多)，就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，

然后进行返回。显然，堆的效率比栈要低得多。

从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片;由于没有专门的系统支持，效率很低;由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。

虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。

无论是堆还是栈，都要防止越界现象的发生(除非你是故意使其越界)，因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生意想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：)

转自：https://www.2cto.com/kf/201802/718986.html

php-ext-xlswriter

与传统的 PHPExcel对比参照如下：

地址：https://xlswriter-docs.viest.me/zh-cn

1位=1比特；

1字节=8位；

1字=2字节；

1字=16位。

1、位

位是计算机存储的最小单位，简记为b，也称为比特（bit）计算机中用二进制中的0和1来表示数据，一个0或1就代表一位。位数通常指计算机中一次能处理的数据大小；

2、比特

比特（bit）是由英文BIT音译而来，比特同时也是二进制数字中的位，是信息量的度量单位，为信息量的最小单位；

3、字节

字节，英文Byte，是计算机用于计量存储容量的一种计量单位，通常情况下一字节等于八位，字节同时也在一些计算机编程语言中表示数据类型和语言字符，在现代计算机中，一个字节等于八位；

4、字

字是表示计算机自然数据单位的术语，在某个特定计算机中，字是其用来一次性处理事务的一个固定长度的位（bit）组，在现代计算机中，一个字等于两个字节。

一、先给定义：

什么是大端？什么是小端？
主要针对的是CPU向内存写入数据的两种方式：

大端序：将高位字节保存在内存的低地址（高位字节在前）的方式。
小端序：将高位字节保存在内在存的高地址（低位字节在前）的方式。

二、下面引入详细说明：

假设在 0x20 号开始的地址中保存4字节 int 型数据 0x12345678，大端序CPU保存方式如下图所示：

上图1：整数 0x12345678 的大端序字节表示。
比如说1在高位就是高位字节，相反8就在低位是低位字节

对于大端序，最高位字节 0x12 存放到低位地址，最低位字节 0x78 存放到高位地址。小端序的保存方式如下图所示：

上图2：整数 0x12345678 的小端序字节表示。
比如说1在高位就是高位字节，相反8就在低位是低位字节

不同CPU保存和解析数据的方式不同（主流的Intel系列CPU为小端序），小端序系统和大端序系统通信时会发生数据解析错误。因此在发送数据前，要将数据转换为统一的格式——网络字节序（Network Byte Order）。网络字节序统一为大端序。主机A先把数据转换成大端序再进行网络传输，主机B收到数据后先转换为自己的格式再解析。网络字节序转换函数
在 sockaddr_in 结构体，其中就用到了网络字节序转换函数，如下所示：

//创建sockaddr_in结构体变量
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr)); //每个字节都用0填充
serv_addr.sin_family = AF_INET; //使用IPv4地址
serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); //具体的IP地址
serv_addr.sin_port = htons(1234); //端口号

htons() 用来将当前主机字节序转换为网络字节序，其中
h代表主机（host）字节序，
n代表网络（network）字节序，
s代表short，htons 是 h、to、n、s 的组合，可以理解为”将short型数据从当前主机字节序转换为网络字节序“。常见的网络字节转换函数有：htons()：host to network short，将short类型数据从主机字节序转换为网络字节序。
ntohs()：network to host short，将short类型数据从网络字节序转换为主机字节序。
htonl()：host to network long，将long类型数据从主机字节序转换为网络字节序。
ntohl()：network to host long，将long类型数据从网络字节序转换为主机字节序。

通常，以s为后缀的函数中，s代表2个字节short，因此用于端口号转换；以l为后缀的函数中，l代表4个字节的long，因此用于IP地址转换。举例说明上述函数的调用过程：

#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>
#pragma comment(lib, "ws2_32.lib")
int main(){
unsigned short host_port = 0x1234, net_port;
unsigned long host_addr = 0x12345678, net_addr;

net_port = htons(host_port);
net_addr = htonl(host_addr);

printf("Host ordered port: %#x\n", host_port);
printf("Network ordered port: %#x\n", net_port);
printf("Host ordered address: %#lx\n", host_addr);
printf("Network ordered address: %#lx\n", net_addr);
system("pause");
return 0;
}

运行结果：

Host ordered port: 0x1234
Network ordered port: 0x3412
Host ordered address: 0x12345678
Network ordered address: 0x78563412

另外需要说明的是，sockaddr_in 中保存IP地址的成员为32位整数，而我们熟悉的是点分十进制表示法，例如 127.0.0.1，它是一个字符串，因此为了分配IP地址，需要将字符串转换为4字节整数。inet_addr() 函数可以完成这种转换。inet_addr() 除了将字符串转换为32位整数，同时还进行网络字节序转换。请看下面的代码：

#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>
#pragma comment(lib, "ws2_32.lib")

int main(){
char *addr1 = "1.2.3.4";
char *addr2 = "1.2.3.256";

unsigned long conv_addr = inet_addr(addr1);
if(conv_addr == INADDR_NONE){
puts("Error occured!");
}else{
printf("Network ordered integer addr: %#lx\n", conv_addr);
}

conv_addr = inet_addr(addr2);
if(conv_addr == INADDR_NONE){
puts("Error occured!");
}else{
printf("Network ordered integer addr: %#lx\n", conv_addr);
}

system("pause");
return 0;
}

运行结果：
Network ordered integer addr: 0x4030201

Error occured!从运行结果可以看出，inet_addr() 不仅可以把IP地址转换为32位整数，还可以检测无效IP地址。注意：为 sockaddr_in 成员赋值时需要显式地将主机字节序转换为网络字节序，而通过 write()/send() 发送数据时TCP协议会自动转换为网络字节序，不需要再调用相应的函数。

本文摘自：https://www.jianshu.com/p/68735394db7a

1. 当线程创建的时候，操作系统（OS）为每一个系统级（system-level）的线程分配栈。通常情况下，操作系统通过调用语言的运行时（runtime）去为应用程序分配堆。
2. 栈附属于线程，因此当线程结束时栈被回收。堆通常通过运行时在应用程序启动时被分配，当应用程序（进程）退出时被回收。
3. 当线程被创建的时候，设置栈的大小。在应用程序启动的时候，设置堆的大小，但是可以在需要的时候扩展（分配器向操作系统申请更多的内存）。
4. 栈比堆要快，因为它存取模式使它可以轻松的分配和重新分配内存（指针/整型只是进行简单的递增或者递减运算），然而堆在分配和释放的时候有更多的复杂的 bookkeeping 参与。另外，在栈上的每个字节频繁的被复用也就意味着它可能映射到处理器缓存中，所以很快。

栈【Stack】:

a.和堆一样存储在计算机 RAM 中。
b.在栈上创建变量的时候会扩展，并且会自动回收。
c.相比堆而言在栈上分配要快的多。
d.用数据结构中的栈实现。
e.存储局部数据，返回地址，用做参数传递。
f.当用栈过多时可导致栈溢出（无穷次（大量的）的递归调用，或者大量的内存分配）。
g.在栈上的数据可以直接访问（不是非要使用指针访问）。
h.如果你在编译之前精确的知道你需要分配数据的大小并且不是太大的时候，可以使用栈。
i.当你程序启动时决定栈的容量上限。

堆【Heap】：

a.和栈一样存储在计算机RAM。
b.在堆上的变量必须要手动释放，不存在作用域的问题。数据可用 delete, delete[] 或者 free 来释放。
c.相比在栈上分配内存要慢。
d.通过程序按需分配。
e.大量的分配和释放可造成内存碎片。
f.在 C++ 中，在堆上创建数的据使用指针访问，用 new 或者 malloc 分配内存。
g.如果申请的缓冲区过大的话，可能申请失败。
h.在运行期间你不知道会需要多大的数据或者你需要分配大量的内存的时候，建议你使用堆。
i.可能造成内存泄露。

定义形式如下：

struct books {
    int count;
    double average;
    double scores[];    //伸缩型数组成员
};

它必须满足以下几点：

1、伸缩型数组必须是结构的最后一个成员；
2、结构中必须至少有一个成员；
3、伸缩型数组类似普通数组，只是它的方括号内必须为空；

它存在的意义：

定义struct books 类型的变量，并不是为了让此数组中存值（初始值）而是希望声明
一个该变量的指针；然后在函数中使用时，动态的分配数组长度以后再赋值。

pf = malloc(sizeof(struct books) + n * sizeof(double)); //这里的n即为伸缩数组的长度

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define SLEN 81

struct namect {
    char * fname; //定义字符指针
    char * lname;
    int letters;
};

void getinfo(struct namect *); //传指针分配内存
void makeinfo(struct namect *);
void showinfo(const struct namect *); //只显示结构内容不能修改结构变量
void cleanup(struct namect *);
char * s_gets(char * st, int n);

int main(void)
{
    struct namect person;
    getinfo(&person);
    makeinfo(&person);
    showinfo(&person);
    cleanup(&person);

    return 0;
}

void getinfo(struct namect * pst)
{
    char temp[SLEN];
    printf("输入英文的姓\n");
    s_gets(temp, SLEN);
    //分配内存
    pst->fname = (char *) malloc(strlen(temp) + 1);
    //把名子拷贝到分配的内在中
    strcpy(pst->fname, temp);
    printf("输入英文的名\n");
    s_gets(temp, SLEN);
    pst->lname = (char *) malloc(strlen(temp) + 1);
    strcpy(pst->lname, temp);
}

void makeinfo(struct namect * pst)
{
    pst->letters = strlen(pst->fname) + strlen(pst->lname);
}

void showinfo(const struct namect * pst)
{
    printf("%s  %s, 你的 %d 字母\n", pst->fname, pst->lname, pst->letters);
}

void cleanup(struct namect * pst)
{
    free(pst->fname);
    free(pst->lname);
}

char * s_gets(char * st, int n)
{
    char * ret_val;
    char * find;

    ret_val = fgets(st, n, stdin);
    if(ret_val) {
        find = strchr(st, '\n');
        if(find) {
            *find = '\0';
        } else {
            while(getchar() != '\n') {
                continue;
            }
        }
    }
    return ret_val;
}