C/C++常见的易模糊知识点(结构体、指针、STL)

简介: C/C++常见的易模糊知识点(结构体、指针、STL)

语法

结构体对齐

三条规则

  • 结构体中元素是按照定义顺序一个一个放到内存中去的,但并不是紧密排列的。从结构体存储的首地址开始,每一个元素放置到内存中时,它都会认为内存是以它自己的大小来划分,因此元素放置的位置一定会在自己宽度的整数倍上开始(以结构体变量首地址为0计算)。
  • 在经过第一原则分析后,检查计算出的存储单元是否为所有元素中最宽的元素的长度的整数倍,是,则结束;若不是,则补齐为它的整数倍。
  • 结构体成员为结构体对象时需要着重理解

分别举例

1. 自己的大小来划分

2. 宽的元素的长度的整数倍

#include <iostream>
using namespace std;
struct X {
    char a;
    int b;
    double c;
}s1;
struct Y {
    char a;
    double b;
    int c;
}s2;
void print1() {
    cout << sizeof(s1) << " ";
    cout << sizeof(s1.a) << " ";
    cout << sizeof(s1.b) << " ";
    cout << sizeof(s1.c) << endl;    
}
void print2() {
    cout << sizeof(s2) << " ";
    cout << sizeof(s2.a) << " ";
    cout << sizeof(s2.b) << " ";
    cout << sizeof(s2.c) << endl;  
}
int main() {
    cout << "顺序char int double " << endl;
    print1();
    cout << "顺序char double int " << endl;
    print2(); // 1+(补7)+8+4 =20; 根据规则二不是 double(8) 的整数倍加4
    return 0;
}
代码结果:
顺序char int double 
16 1 4 8   # 规则一:1+(补3)+4+8=16
顺序char double int 
24 1 8 4   #分析 1+(补7)+8+4 =20; 根据规则二不是 double(8) 的整数倍,需20+4=24

图例

3.结构体成员为结构体对象时

#include <iostream> 
using namespace std;
struct X {
    char a;
    int b;
    double c;
};
struct Y {
    X b;
    char a;  
};
void print() {
    cout << "X 的内存大小为:" << sizeof(X) << endl;
    cout << "Y 的内存大小为:" << sizeof(Y) << endl;
}
int main () {
    print();
    return 0;
}
代码结果:
X 的内存大小为:16   # 1+(补3)+4+8=16
Y 的内存大小为:24   # b 前 a 后 :16+1+(补7,补至8的倍数) = 24 
# 若 a 前 b 后:1+(补7,补至8的倍数)+16=24

分析:

计算Y的存储长度时,在存放第二个元素b时的初始位置是在double型的长度8的整数倍处,而非16的整数倍处,即系统为b所分配的存储空间是第8~23个字节。

如果将Y的两个元素char型的a和X型的b调换定义顺序(b 前a 后),则系统为b分配的存储位置是第0~15个字节,为a分配的是第16个字节,加起来一共17个字节,不是最长基本类型double所占宽度8的整数倍,因此要补齐到8的整数倍,即24。

修改默认对齐数

预处理指令: #pragma

#include <iostream>
using namespace std;
struct s1
{
  double a;
  char b;
  int c;
};
#pragma pack(4)  //数据成员对齐数 = min( 修改后的默认对齐数(4) ,该数据类型大小 )
struct s2
{
  char a;
  struct s1 s11;
  double b;
};
#pragma pack()
int main()
{
  printf("s1的大小:%d\n", sizeof(s1));
  printf("s2的大小:%d\n", sizeof(s2));
  return 0;
}
代码结果:
s1的大小:16
s2的大小:28   # 1+(补3,补至4的倍数)+16+8=28
  1. char a; // 地址从0开始,第一个字节存的是char
  2. struct s1 s11; // min( 4 ,max(double,char,int)) = 4 ,此时下标是1,1不是4的整数倍,补3个空字节,再存入s11(16个字节)
  3. double b; // min(4,8) = 4 ,此时下标是20,20是4的整数倍,再存入double
  4. 共存了1+3+16+8=28个字节,整体对齐数 = min(4,max( char, struct s1, double )) = 4,28是4的整数倍,不用补空字节。

int a[ ]中 a 与 &a区别

a 作为右值时与 &a[0] 意义相同,代表数组首元素地址;

&a 是取数组 a 的首地址,&a+1是 &a + 5*sizeof(int);

a 是首元素首地址,即&a[0];&a 是数组首地址,虽然数值上相同,但是意义不相同。

#include <iostream>
using namespace std;
int main() {
    int a[5] = {1,2,3,4,5};
    int* ptr = (int* )(&a + 1);
    printf("%d,%d", *(a + 1), *(ptr - 1));  //2, 5
    return 0;
}

捋清楚这个代码的结果

#include <iostream>
using namespace std;
struct Test {
    int a;
    char* b;
    short c;
    char d[2];
    short e[4];
}*p;
int main() {
    cout << "sizrof(short) = " << sizeof(short) << endl;
    cout << "sizeof(struct Test) = " << sizeof(struct Test) << endl;
    cout << "sizeof(*p) = " << sizeof(*p) << endl;
    cout << "p = " << p << " p + 0x1 = " << p + 0x1 << endl;
    cout << "(unsigned long)p = " << p << " unsigned long)p + 0x1 = " << p + 0x1;
    return 0;
}

确定系统大小端

什么是大小端?

大端模式(Big.endian):字数据的高字节存储在低地址中,而字数据的低字节则存放在高地址中。

小端模式(Little_endian):字数据的高字节存储在高地址中,而字数据的低字节则存放在低地址中。

图例

确定系统大小端代码

#include <iostream> 
using namespace std;
int checkSystem() {
    union check{
        int i;
        char ch;     
    }c;
    c.i = 1;
    return (c.ch == 1);
}
int main () {
    int a = checkSystem();
    cout << a;   //输出为1 则为小端模式,0 则为大端模式
    return 0;
}

一道考验题

在大端模式与小端模式下的输出结果分别是什么?

#include <iostream>
using namespace std;
void print() {
    union check{
      int i;
      char a[2];
    }*p, u;
    p = &u;
    p->a[0] = 0x39;
    p->a[1] = 0x38;
    cout << "p->i = " << p->i;
}
int main() {
    print();
    return 0;
}
小端模式下代码运行结果:
p->i = 14393

结果分析

3889(h) = 14393(d)


再来一道网络难题

计算一下输出结果!

#include <iostream>
using namespace std;
int main() {
    int a[4] = {1,2,3,4};
    int* ptr1 = (int* )(&a + 1);
    int* ptr2 = (int* )((long)a + 1);
    printf("%x, %x", ptr1[-1], *ptr2);
    return 0;
}
代码运行结果:
4, 2000000   # 在小端模式下
4, 100       # 在大端模式下

分析

ptr1:将&a+1的值强制转换成int*类型,赋值给int*类型的变量 ptr,ptrl 肯定指到数组a的下一个int类型数据了。ptr1[-1]被解析成* (ptr1-1),即ptrl往后退4字节,所以其值为0x4。

ptr2:按照上面的讲解,(int)a+1的值是元素a[0]的第2个字节的地址,然后把这个地址强制转换成int*类型的值赋给ptr2,也就是说*ptr2的值应该为元素a[0]的第2个字节开始的连续4字节的内容。

小端模式下

大端模式下

参考文章链接

  1. Byte and Bit Order Dissection
  2. 大小端对字节序和位序的影响

二维数组

内存相当于尺子,最小单位为字节;二维数组也是存在尺子当中的。

看成这样很重要

来一道题

#include <iostream>
using namespace std;
int main() {
    int a[3][2] = {(0,1), (2,3), (4,5)};
    int* p = a[0];
    /*for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j ++) 
            cout << a[i][j] << " ";
        cout << endl;
    }*/
    printf("%d", p[0]);  //1
    return 0;
}

分析

花括号里面嵌套的是小括号,而不是花括号!这里是花括号里面嵌套了逗号表达式,
其实这个赋值就相当于int a[3][2]={1, 3, 5}。

再来一道号称很难做对的题 &p[4][2] - &a[4][2]

#include <stdio.h>
int main() {
    int a[5][5];
    int (*p)[4];
    p = a;
    printf("a_ptr = %#p, p_ptr = %#p\n", &a[4][2], &p[4][2]);
    printf("%p, %d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}
代码运行结果:
a_ptr = 0x7fff23bcfdc8, p_ptr = 0x7fff23bcfdb8
0xfffffffffffffffc, -4

分析理解

  • 首先明确数组名 a 作为右值时,代表数组首元素地址,即 a 代表 a[0]地址。
  • &a[4][2]表示的是&a[0][0]+4*5*sizeof(int)+ 2 * sizeof(int)。
  • p 是指向四个元素的数组指针,也就是说 p+1 表示指针 p 向后移动“包含4个int类型元素的数组”。
  • 由于p被初始化为&a[0],所以&p[4][2]表示的是&a[0][0]+4 *4sizeof(int)+2*sizeof(int)


二维数组与二维指针

二维数组参数与二维指针参数关系


函数指针

简单看下函数指针用法

#include <stdio.h>
#include <string.h>
char* fun(char* p1, char* p2) {
    int i = 0;
    i = strcmp(p1, p2);
    if (i == 0) return p1;
    else return p2;
}
int main() {
    char * (*pf)(char* p1, char* p2);
    pf = &fun;
    (*pf)("aa", "bb");
    return 0;
}

理解* (int* )&p = (int)Function做了什么

#include <stdio.h>
void Function() {
    printf("call Function");
}
int main() {
    void (*p)();
    * (int* )&p = (int)Function;
    (*p)();
    return 0;
}

分析

  • (int*)&p表示将地址强制转换成指向int类型数据的指针。
  • (int)Function表示将函数的人口地址强制转换成int类型的数据。
  • “* (int* ) &p= (int) Function;"表示将函数的人口地址赋值给指针变量p。

再来一个(*(void(*)())0)()的理解分析:

  • 第1步:void( * ) (),可以明白这是-一个函数指针类型。这个函数没有参数,没有返回值;
  • 第2步:(void( * ) ())0,这是将0强制转换为函数指针类型,0是一个地址,也就是说一个函数保存在首地址为0的一段区域内;
  • 第3步:(*(void(*)())0),这是取0地址开始的一段内存里面的内容,其内容就是保存在首地址为0的一段区域内的函数;
  • - 第4步:( * (void( * ) ())0)(),这是函数调用。

函数指针数组与函数指针数组指针

函数指针数组

  • char* (*pf)(char* p)不难理解!
  • char* (*pf[3])(char* p) 就是函数指针数组。
  • pf并非指针,而是一个数组名,数组存储了3个指向函数的指针

函数指针数组指针

  • char* (*(*pf)[3])(char* p)就是函数指针数组指针!!!
    pf 是实实在在的指针,这个指针指向一个包含了3个元素的数组;这个数组里面存的是指向函数的指针
//指针函数数组指针的应用
#include <stdio.h>
#include <string.h>
char* func1(char* p) {
    printf("%s\n", p);
    return p;
}
char* func2(char* p) {
    printf("%s\n", p);
    return p;
}
char* func3(char* p) {
    printf("%s\n", p);
    return p;
}
int main() {
    char* (*a[3])(char* p);
    char* (*(*pf)[3])(char* p);
    pf = &a;
    a[0] = &func1;
    a[1] = &func2;
    a[2] = &func3;
    pf[0][0]("func1");  //等价(*pf)[0]("func1")
    pf[0][1]("func2");
    pf[0][2]("func3");
    return 0;
}

typedef

与回调函数相关的应用:C/C++ typedef 用法

STL标准库

List底层实现原理

原理图

deque 底层原理

priority_queue 底层原理(容器适配器)




相关文章
|
缓存 安全 编译器
C++面试周刊(3):面试不慌,这样回答指针与引用,青铜秒变王者
《C++面试冲刺周刊》第三期聚焦指针与引用的区别,从青铜到王者级别面试回答解析,助你21天系统备战,直击高频考点,提升实战能力,轻松应对大厂C++面试。
1149 132
C++面试周刊(3):面试不慌,这样回答指针与引用,青铜秒变王者
|
编译器 C++ 容器
【c++丨STL】基于红黑树模拟实现set和map(附源码)
本文基于红黑树的实现,模拟了STL中的`set`和`map`容器。通过封装同一棵红黑树并进行适配修改,实现了两种容器的功能。主要步骤包括:1) 修改红黑树节点结构以支持不同数据类型;2) 使用仿函数适配键值比较逻辑;3) 实现双向迭代器支持遍历操作;4) 封装`insert`、`find`等接口,并为`map`实现`operator[]`。最终,通过测试代码验证了功能的正确性。此实现减少了代码冗余,展示了模板与仿函数的强大灵活性。
516 2
|
缓存 算法 程序员
C++STL底层原理:探秘标准模板库的内部机制
🌟蒋星熠Jaxonic带你深入STL底层:从容器内存管理到红黑树、哈希表,剖析迭代器、算法与分配器核心机制,揭秘C++标准库的高效设计哲学与性能优化实践。
1035 3
C++STL底层原理:探秘标准模板库的内部机制
|
存储 C++
C++语言中指针变量int和取值操作ptr详细说明。
总结起来,在 C++ 中正确理解和运用 int 类型地址及其相关取值、设定等操纵至关重要且基础性强:定义 int 类型 pointer 需加星号;初始化 pointer 需配合 & 取址;读写 pointer 执向之处需配合 * 解引用操纵进行。
918 12
|
存储 算法 C++
【c++丨STL】map/multimap的使用
本文详细介绍了STL关联式容器中的`map`和`multimap`的使用方法。`map`基于红黑树实现,内部元素按键自动升序排列,存储键值对,支持通过键访问或修改值;而`multimap`允许存在重复键。文章从构造函数、迭代器、容量接口、元素访问接口、增删操作到其他操作接口全面解析了`map`的功能,并通过实例演示了如何用`map`统计字符串数组中各元素的出现次数。最后对比了`map`与`set`的区别,强调了`map`在处理键值关系时的优势。
1011 73
|
存储 缓存 C++
C++ 容器全面剖析:掌握 STL 的奥秘,从入门到高效编程
C++ 标准模板库(STL)提供了一组功能强大的容器类,用于存储和操作数据集合。不同的容器具有独特的特性和应用场景,因此选择合适的容器对于程序的性能和代码的可读性至关重要。对于刚接触 C++ 的开发者来说,了解这些容器的基础知识以及它们的特点是迈向高效编程的重要一步。本文将详细介绍 C++ 常用的容器,包括序列容器(`std::vector`、`std::array`、`std::list`、`std::deque`)、关联容器(`std::set`、`std::map`)和无序容器(`std::unordered_set`、`std::unordered_map`),全面解析它们的特点、用法
1199 1
C++ 容器全面剖析:掌握 STL 的奥秘,从入门到高效编程
|
C++ 容器
【c++丨STL】stack和queue的使用及模拟实现
本文介绍了STL中的两个重要容器适配器:栈(stack)和队列(queue)。容器适配器是在已有容器基础上添加新特性或功能的结构,如栈基于顺序表或链表限制操作实现。文章详细讲解了stack和queue的主要成员函数(empty、size、top/front/back、push/pop、swap),并提供了使用示例和模拟实现代码。通过这些内容,读者可以更好地理解这两种数据结构的工作原理及其实现方法。最后,作者鼓励读者点赞支持。 总结:本文深入浅出地讲解了STL中stack和queue的使用方法及其模拟实现,帮助读者掌握这两种容器适配器的特性和应用场景。
568 21
|
存储 算法 C++
【c++丨STL】set/multiset的使用
本文深入解析了STL中的`set`和`multiset`容器,二者均为关联式容器,底层基于红黑树实现。`set`支持唯一性元素存储并自动排序,适用于高效查找场景;`multiset`允许重复元素。两者均具备O(logN)的插入、删除与查找复杂度。文章详细介绍了构造函数、迭代器、容量接口、增删操作(如`insert`、`erase`)、查找统计(如`find`、`count`)及`multiset`特有的区间操作(如`lower_bound`、`upper_bound`、`equal_range`)。最后预告了`map`容器的学习,其作为键值对存储的关联式容器,同样基于红黑树,具有高效操作特性。
885 3
|
存储 算法 C++
【c++丨STL】priority_queue(优先级队列)的使用与模拟实现
本文介绍了STL中的容器适配器`priority_queue`(优先级队列)。`priority_queue`根据严格的弱排序标准设计,确保其第一个元素始终是最大元素。它底层使用堆结构实现,支持大堆和小堆,默认为大堆。常用操作包括构造函数、`empty`、`size`、`top`、`push`、`pop`和`swap`等。我们还模拟实现了`priority_queue`,通过仿函数控制堆的类型,并调用封装容器的接口实现功能。最后,感谢大家的支持与关注。
1148 1
|
算法 C语言 C++
【c++丨STL】list的使用
本文介绍了STL容器`list`的使用方法及其主要功能。`list`是一种双向链表结构,适用于频繁的插入和删除操作。文章详细讲解了`list`的构造函数、析构函数、赋值重载、迭代器、容量接口、元素访问接口、增删查改操作以及一些特有的操作接口如`splice`、`remove_if`、`unique`、`merge`、`sort`和`reverse`。通过示例代码,读者可以更好地理解如何使用这些接口。最后,作者总结了`list`的特点和适用场景,并预告了后续关于`list`模拟实现的文章。
656 7