Vector

一、resize和reserve

size(长度)：vector当前拥有的元素个数。

capacity(空间):vector中最多能存储的元素个数，是预分配存储空间的大小。

1.resize()        

change size

原型：void resize (size_type n);
           void resize (size_type n, const value_type& val);

用法：resize（n）

           resize（n，val）

功能：调整容器的长度大小，使其包含n个元素。

n<size	保留前n个元素，其余删除并销毁
size<n<capacity	在尾部插入所需数量的新元素，以达到n
n>capacity	重新分配内存空间，尾部插入元素以达到n

实质：改变size，n即为新的size，继而影响capacity。

// resizing vector
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector;

  // set some initial content:
  for (int i=1;i<10;i++) myvector.push_back(i);

  myvector.resize(5);
  myvector.resize(8,100);
  myvector.resize(12);

  std::cout << "myvector contains:";
  for (int i=0;i<myvector.size();i++)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

---

2.reserve()

change capacity

原型：void reserve (size_type n);

用法：reserve(n)

功能：预开辟n个元素的空间。

n>capacity	重新分配空间，使capacity=n
n<=capacity	不改变

// vector::reserve
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int>::size_type sz;

  std::vector<int> foo;
  sz = foo.capacity();
  std::cout << "making foo grow:\n";
  for (int i=0; i<100; ++i) {
    foo.push_back(i);
    if (sz!=foo.capacity()) {
      sz = foo.capacity();
      std::cout << "capacity changed: " << sz << '\n';
    }
  }

  std::vector<int> bar;
  sz = bar.capacity();
  bar.reserve(100);   // this is the only difference with foo above
  std::cout << "making bar grow:\n";
  for (int i=0; i<100; ++i) {
    bar.push_back(i);
    if (sz!=bar.capacity()) {
      sz = bar.capacity();
      std::cout << "capacity changed: " << sz << '\n';
    }
  }
  return 0;
}

output：making foo grow:
 capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128
making bar grow:
capacity changed: 100

---

总结：

1）resize()函数对vector的影响。
size：调用resize(n)后，vector的size即为n，且其中元素都为0。
capacity：取决于调整后的容器的size是否大于capacity。如果调整后size大于capacity，则capacity调整为size大小，否则不变。

2）reserve()函数对vector影响
capacity：调用reserve(n)后，若容器的capacity<n，则重新分配内存空间，从而使得capacity等于n。如果capacity>=n呢？capacity无变化。

---

二、结构体对齐

1、原因：许多计算机系统对基本数据类型的可允许地址做出了一些限制，要求某种类型的对象的地址必须是某个值K（通常是2，4，8）的倍数，而这个k则被称为该数据类型的对齐模数(alignment modulus)。这种对其限制不仅简化了处理器与存储系统之间的接口的硬件设计，而且提高了存储系统的性能

2、步骤：1.结构体成员对齐    2.结构体整体对齐

3.规则：（1）第一个元素放在地址偏移量为0的位置。

         （2）其余元素对齐时，放在偏移量为min（自身对齐数，指定对齐数）最小整数倍的位置。

   （3）结构体整体对齐时，字节大小应为min（所有成员中自身对齐数最大的，指定对齐数）最小整数倍的位置。

注：自身对齐数（成员变量自身长度大小）                                          eg：int a 自身对齐数为4

      指定对齐数（有宏 #pragma pack(N) 指定的值,这里面的 N一定是2的幂次方.如1,2,4,8,16等.如果没有通过宏那么在32位Linux主机上默认指定对齐值为4,64位的默认对齐值为8,AMR CPU默认指定对齐值为8）

      有效对齐数（自身对齐数和指定对齐数的较小值）

---

//此代码在64位Linux下编写
typedef struct _st_struct1
 {
	char 	a;
	short   b;
	int		c;
 }st_struct1;
 
 printf("%ld\n",sizeof(st_struct1));

打印结果为:8. 让我们分析一下为什么结果为8.
a是char类型,占1个字节.第一个数据成员,放在结构体变量偏移量为0 的地址处.
b是short类型,占2个字节,接下来我们要看结构体对齐规则,b的有效对齐值为min{2, 8}=2. 依次查看2的整数倍地址是否可以存放俩个字节.2×0=0 //此地址处已经存放a. 2×1=2 //此地址为空,我们将占有俩个字节的b存放在地址偏移量为2和3处.
c是int类型,占4个字节,我们根据结构体对齐规则可知,c的有效对齐值为4.对齐到4的整数倍地址,即地址偏移量为4处.在内存中存放的位置为4,5,6,7.
结构体总对齐字节大小为min{4, 8}=4 的整数倍.此时内存中共占8个字节,正好是4的整数倍,所以sizeof(st_struct1)=8.
占用内存空间如下：

原文链接：https://blog.csdn.net/weixin_45157820/article/details/112755832