要了解这里发生了什么，您需要了解一点与 R 中的对象相关的内存开销。每个对象，即使是没有数据的对象，都有 40 字节的数据与之相关：
x0 <- numeric()
object.size(x0)
# 40 bytes
此内存用于存储对象的类型（由 返回typeof()）以及内存管理所需的其他元数据。
忽略此开销后，您可能会认为向量的内存使用量与向量的长度成正比。让我们用几个图来检查一下：
sizes <- sapply(0:50, function(n) object.size(seq_len(n)))
plot(c(0, 50), c(0, max(sizes)), xlab = "Length", ylab = "Bytes",
type = "n")
abline(h = 40, col = "grey80")
abline(h = 40 + 128, col = "grey80")
abline(a = 40, b = 4, col = "grey90", lwd = 4)
lines(sizes, type = "s")
看起来内存使用量与向量的长度大致成正比，但在 168 字节处有一个很大的不连续性，每隔几步就有一个小的不连续性。最大的不连续性是因为 R 有两个用于向量的存储池：由 R 管理的小向量和由操作系统管理的大向量（这是一种性能优化，因为分配大量少量内存很昂贵）。小向量只能是 8、16、32、48、64 或 128 字节长，一旦我们去除 40 字节开销，这正是我们所看到的：
sizes - 40
# [1] 0 8 8 16 16 32 32 32 32 48 48 48 48 64 64 64 64 128 128 128 128
# [22] 128 128 128 128 128 128 128 128 128 128 128 128 136 136 144 144 152 152 160 160 168
# [43] 168 176 176 184 184 192 192 200 200
从 64 到 128 的步长导致了大步，然后一旦我们进入大向量池，向量被分配为 8 个字节的块（内存以一定大小为单位，R 不能要求半个单元）：
# diff(sizes)
# [1] 8 0 8 0 16 0 0 0 16 0 0 0 16 0 0 0 64 0 0 0 0 0 0 0 0 0 0 0
# [29] 0 0 0 0 8 0 8 0 8 0 8 0 8 0 8 0 8 0 8 0 8 0
那么这种行为如何与您在矩阵中看到的相对应？好吧，首先我们需要查看与矩阵相关的开销：
xv <- numeric()
xm <- matrix(xv)
object.size(xm)
# 200 bytes
object.size(xm) - object.size(xv)
# 160 bytes
因此，与向量相比，矩阵需要额外 160 字节的存储空间。为什么是 160 字节？这是因为矩阵有一个dim包含两个整数的属性，并且属性存储在一个pairlist（旧版本list()）中：
object.size(pairlist(dims = c(1L, 1L)))
# 160 bytes
如果我们使用矩阵而不是向量重新绘制之前的图，并将 y 轴上的所有常数增加 160，您可以看到不连续性正好对应于从小向量池到大向量池的跳转：
msizes <- sapply(0:50, function(n) object.size(as.matrix(seq_len(n))))
plot(c(0, 50), c(160, max(msizes)), xlab = "Length", ylab = "Bytes",
type = "n")
abline(h = 40 + 160, col = "grey80")
abline(h = 40 + 160 + 128, col = "grey80")
abline(a = 40 + 160, b = 4, col = "grey90", lwd = 4)
lines(msizes, type = "s")
这似乎只发生在小端非常特定的列范围内。查看具有 1-100 列的矩阵，我看到以下内容：
即使我将列数增加到 10000，我也看不到任何其他平台：
很感兴趣，我进一步研究了，将您的代码放在一个函数中：
sizes <- function(nrow, ncol) {
size=matrix(1:ncol,ncol,2)
for (i in c(1:ncol)){
m = matrix(1,nrow, i)
size[i,2]=object.size(m)
}
plot(size[,1], size[,2])
size
}
有趣的是，如果我们增加行数，我们仍然会看到这个平台和直线的数量很少，平台缩小并向后移动，然后在我们击中时最终调整为一条直线nrow=8：
表明这发生在矩阵中单元格数量的非常特定范围内；9-16。
内存分配
正如@Hadley 在他的评论中指出的那样，vectors 的内存分配也有类似的主题。它提出了公式：40 + 8 * floor(n / 2)对于numericsize 的向量n。
对于矩阵，开销略有不同，步进关系不成立（如我的图中所示）。相反，我提出了公式208 + 8 * nbytes 其中n是矩阵 ( nrow * ncol) 中的单元格数，除了在n9 和 16 之间：
矩阵大小 - 208 字节的"double"矩阵，1 行，1-20 列：
> sapply(1:20, function(x) { object.size(matrix(1, 1, x)) })-208
[1] 0 8 24 24 40 40 56 56 120 120 120 120 120 120 120 120 128 136 144
[20] 152
然而。如果我们将矩阵的类型更改为整数或逻辑，我们确实会看到上面线程中描述的内存分配中的逐步行为：
"integer"矩阵大小 - 1 行 1-20 列的矩阵为 208 个字节：
> sapply(1:20, function(x) { object.size(matrix(1L, 1, x)) })-208
[1] 0 0 8 8 24 24 24 24 40 40 40 40 56 56 56 56 120 120 120
[20] 120
同样对于"logical"矩阵：
> sapply(1:20, function(x) { object.size(matrix(1L, 1, x)) })-208
[1] 0 0 8 8 24 24 24 24 40 40 40 40 56 56 56 56 120 120 120
[20] 120
令人惊讶的是，我们没有看到类型矩阵的相同行为double，因为它只是一个"numeric"带有dim属性的向量（R 语言规范）。
我们在内存分配中看到的一大步来自于R拥有两个内存池，一个用于小向量，一个用于大向量，而这恰好是跳转的地方。Hadley Wickham 在他的回复中详细解释了这一点。
看看大小从 1 到 20 的数字向量，我得到了这个数字。
x=20
size=matrix(1:x,x,2)
for (i in c(1:x)){
m = rep(1, i)
size[i,2]=object.size(m)
}
plot(size[,1],size[,2])
