CPP指针深析

深技大c++实验2-指针1 我打算在这个学期写一下我的SZTU c++实验的代码,以供参考,也是方便自己复习的时候知道自己当时的想法,非常欢迎各位大佬提出宝贵的意见。尽量能做到每次都更新吧,这次实验是指针第一部分,考察了常量指针,指针运算,指针与数组的相关操作。 阅读详情

CPP指针深析

指针对于初学者往往是很难以琢磨的东西,因为它并不如变量那么抽象,而是更贴近底层的真实结构。指针操作往往会出现各种各样的岔子,最常见的便是”segmentation fault”。所以这里辨析了各种指针类型,实践出真知,下面的例子如果自己敲下来就更好了😁😁😁。

指针是C++中强大的工具,灵活但容易出错。
优化界面的Blog:CPP指针复习

1. 指针的基本概念

指针是一种保存地址的变量。

int a = 10;
int* p = &a; // p保存a的地址
std::cout << "Value of a: " << *p << std::endl; // 解引用获取a的值
  • &:取地址符,获取变量地址。
  • *:解引用符,通过地址访问变量值。

注意:未初始化的指针称为野指针,会导致未定义行为。

int* p; // 未初始化
std::cout << *p << std::endl; // 未定义行为

2. 指针的分类与使用

2.1 空指针

空指针(nullptr)指向“无效”地址,避免野指针问题。

int* p = nullptr; 
if (p == nullptr) {
    std::cout << "Pointer is null" << std::endl;
}

注意:解引用空指针会引发运行时错误。


2.2 常量指针和指针常量

  • 常量指针:指向的值不能修改。
const int a = 10;
const int* p = &a; 
//*p = 20; // 错误,值不可修改
p = nullptr; // 指针本身可以指向其他地址
  • 指针常量:指针的地址不能修改。
int b = 10, c = 20;
int* const p = &b;
//p = &c; // 错误,指针地址不可修改
*p = 30; // 正确,值可以修改
  • 指向常量的指针常量:
const int a = 10;
const int* const p = &a;
//*p = 20; // 错误
//p = &b; // 错误

2.3 指针与数组

指针与数组关系密切,数组名即为首元素地址:

int arr[] = {1, 2, 3};
int* p = arr;
std::cout << p[1] << std::endl; // 输出 2

使用指针操作数组:

for (int i = 0; i < 3; ++i) {
    std::cout << *(p + i) << " "; // 依次输出数组元素
}

2.4 指针与函数

指针可用于传递函数参数,实现高效操作:

void swap(int* x, int* y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int a = 10, b = 20;
swap(&a, &b); 
std::cout << a << " " << b << std::endl; // 输出 20 10

2.4 指针与函数

指针可用于传递函数参数,实现高效操作:

void swap(int* x, int* y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int a = 10, b = 20;
swap(&a, &b); 
std::cout << a << " " << b << std::endl; // 输出 20 10

2.5 动态内存分配与指针

通过new和delete动态分配内存:

int* p = new int(42); 
std::cout << *p << std::endl; // 输出 42
delete p; // 释放内存

动态数组:

int* arr = new int[5];
for (int i = 0; i < 5; ++i) arr[i] = i + 1;
delete[] arr; // 释放动态数组

注意:

  • 忘记释放内存会导致内存泄漏。
  • 使用delete释放后,不要再解引用。

2.6 指针与多级指针

多级指针是指向指针的指针:

int a = 10;
int* p1 = &a;
int** p2 = &p1; // p2指向p1
std::cout << **p2 << std::endl; // 输出10

3. 常见问题与调试技巧

  1. 空指针解引用

    int* p = nullptr;
    std::cout << *p << std::endl; // segmentation fault
    
  2. 指针越界

    int arr[3] = {1, 2, 3};
    int* p = arr + 3; // 超出数组范围
    std::cout << *p << std::endl; // 未定义行为
    
  3. 野指针

    int* p;
    delete p; // p未指向有效地址
    

调试方法:

  • 检查nullptr。
  • 使用工具(如Valgrind)检测内存泄漏。
  • 避免无意义的解引用操作。

4. 总结

指针的强大功能伴随着复杂性和风险。通过反复实践和注重细节,可以掌握指针的精髓,写出高效可靠的C++代码。初学者特别要注意避免未定义行为,同时养成良好的编码习惯。

const修饰指针

#include <iostream>

using namespace std;

class Rectangle{
  public:
  	Rectangle(int length, int width){chang=length; kuan=width;}
    void SetLength(int length){ chang=length;}
    int GetLength() const{ return chang;}
  private:
    int chang;
    int kuan;
};

int main(){
  // int a=123;
  // const int *p=&a;//const 修饰*,p可以改
  // cout<<*p<<endl;
  // int b=567;
  // p=&b;
  // cout<<*p<<endl;
  // int const *p1=&a;
  // int * const p2=&b;const 修饰p2,*p2可以改
  // *p2=789;
  // // p2=&a;
  // cout<<*p2<<endl;

  Rectangle *rec=new Rectangle(123, 456);
  Rectangle *rec1=new Rectangle(789, 456);
  cout<<rec->GetLength()<<endl;

  const Rectangle * pRec=rec;
  cout<<pRec->GetLength()<<endl;
  pRec=rec1;//同p
  cout<<pRec->GetLength()<<endl;//只能调用const方法
  Rectangle * const pRec1=rec;//同p2
  cout<<pRec1->GetLength()<<endl;
  Rectangle *pPrec0=rec;
  pPrec0->SetLength(789);//非const方法也可以调用
  cout<<pRec->GetLength()<<endl;

}

这段代码通过一些实例讲解了const修饰指针的不同用法,并结合类的const方法,展示了指针常量和指向常量的指针的区别。以下是代码运行的核心分析:


核心概念解析

1. const修饰指针的两种情况
  1. 指向常量的指针(const修饰指向内容)

    • 指针可以指向不同地址,但指向的内容不可修改。
    const int *p = &a; // 或 int const *p = &a;
    p = &b;           // OK: 修改指针地址
    *p = 10;          // 错误: 修改指向内容
    
  2. 指针常量(const修饰指针本身)

    • 指针地址不可修改,但指向的内容可以改。
    int *const p = &a;
    p = &b;           // 错误: 修改指针地址
    *p = 10;          // OK: 修改指向内容
    

2. 类中的const方法
  • const方法:

    方法后加const,表示该方法不会修改类的成员变量。

    int GetLength() const; // 只读方法
    

    如果通过const对象(或const指针)调用方法,只能调用const方法。


代码行为解析

(1)创建普通对象和指针
Rectangle *rec = new Rectangle(123, 456);
Rectangle *rec1 = new Rectangle(789, 456);
cout << rec->GetLength() << endl; // 输出 123
  • rec是普通指针,能自由调用非const方法。
(2)指向常量的指针
const Rectangle *pRec = rec; // pRec指向一个常量对象
cout << pRec->GetLength() << endl; // 输出 123
pRec = rec1; // OK: 修改指针地址
cout << pRec->GetLength() << endl; // 输出 789
// pRec->SetLength(456); // 错误: 无法调用非const方法
  • pRec只能调用const方法(GetLength),但可以指向其他Rectangle对象。
(3)指针常量
Rectangle *const pRec1 = rec; // pRec1为指针常量
cout << pRec1->GetLength() << endl; // 输出 123
pRec1->SetLength(789); // OK: 可调用非const方法修改内容
cout << pRec1->GetLength() << endl; // 输出 789
// pRec1 = rec1; // 错误: 无法修改指针地址
  • pRec1的指向地址不可修改,但其内容可以更改。
(4)普通指针调用非const方法
Rectangle *pPrec0 = rec;
pPrec0->SetLength(789); // 调用非const方法
cout << pRec->GetLength() << endl; // 输出 789
  • pPrec0是普通指针,可以自由调用非const方法。

输出结果

最终输出如下:

123
123
789
123
789

总结

  • const修饰指针的用法: 分清指向内容和指针本身谁是常量。
  • 类的const方法: 适用于保护类状态,在需要只读访问时尤为重要。
  • 实践建议: 在需要只读访问的场景下,优先使用const指针和const方法,提高代码的安全性和可维护性。

一维数组指针的区别

a代表首地址,在sizeof和&a时当成了数组整体

#include <iostream>
using namespace std;
#define sz(type) cout<<sizeof(type)<<endl;
int main(){
  int a[3]={12,13,14};
  sz(a);
  cout<<a<<endl;
  cout<<&a<<endl;
  cout<<&a[0]<<endl;
  /*
  12
  0x9ffdb4
  0x9ffdb4
  0x9ffdb4
  */

  cout<<endl;
  cout<<a<<" "<<a+1<<" "<<a+2<<endl;            //a = &a[0] != &a
  cout<<&a<<" "<<&a+1<<" "<<&a+2<<endl;
  cout<<&a[0]<<" "<<&a[0]+1<<" "<<&a[0]+2<<endl;
  /*
  0x9ffdb4 0x9ffdb8 0x9ffdbc  //步长是4,一个int
  0x9ffdb4 0x9ffdc0 0x9ffdcc  //步长是12,三个int,也就是数组长度
  0x9ffdb4 0x9ffdb8 0x9ffdbc  //步长是4,一个int
  */
  return 0;
}

这个代码的核心在于区分一维数组的 数组名 和 数组地址 的概念,并通过sizeof和地址输出展示了它们的差异。下面详细解析这段代码及其输出。


核心概念解析

1. 数组名 a
  • 数组名(如 a)是一个特殊的指针,默认指向数组的首元素,即 &a[0]。
  • 但在某些特定场景中,a表现为整个数组的标志,比如 sizeof(a) 和 &a。

2. sizeof 的作用
  • sizeof(a):计算数组整体的字节大小(数组长度 × 元素大小)。
  • sizeof(&a):计算指向数组的指针的大小,与平台有关(通常是4字节或8字节)。
3. &a 和 a 的区别
  • a 是指向首元素的指针,等同于 &a[0]。
  • &a 是整个数组的地址,表示一个数组整体。

两者类型不同:

  • a 的类型是 int*,步长是单个元素的大小(sizeof(int))。
  • &a 的类型是 int(*)[3],步长是整个数组的大小(sizeof(a))。

4. 地址运算
  1. a + i:表示第 i 个元素的地址。
  2. &a + i:表示第 i 个数组的地址,步长是数组大小(即 3 × sizeof(int))。
  3. &a[0] + i:等价于 a + i,表示第 i 个元素的地址。

代码解析及输出

sizeof 示例
sz(a); // 数组整体大小:3 × sizeof(int) = 12(假设int为4字节)

输出:

12

地址比较
cout << a << endl;       // 数组首元素地址:&a[0]
cout << &a << endl;      // 数组整体地址
cout << &a[0] << endl;   // 数组首元素地址:&a[0]

输出:

0x9ffdb4  // 假设是数组的首地址,a 等价于 &a[0]
0x9ffdb4  // &a 表示数组整体的地址,与首地址相同,但意义不同
0x9ffdb4  // &a[0] 是首元素地址

地址偏移
cout << a << " " << a+1 << " " << a+2 << endl;  // 步长是单个元素的大小
cout << &a << " " << &a+1 << " " << &a+2 << endl; // 步长是整个数组的大小
cout << &a[0] << " " << &a[0]+1 << " " << &a[0]+2 << endl; // 步长是单个元素的大小

输出:

0x9ffdb4 0x9ffdb8 0x9ffdbc  // a,步长是4字节(1个int大小)
0x9ffdb4 0x9ffdc0 0x9ffdcc  // &a,步长是12字节(整个数组大小)
0x9ffdb4 0x9ffdb8 0x9ffdbc  // &a[0],步长是4字节(1个int大小)

总结

  1. a 与 &a 的区别:
    • a 是指向首元素的指针,类型是 int*,步长是单个元素的大小。
    • &a 是指向整个数组的指针,类型是 int(*)[3],步长是整个数组的大小。
  2. sizeof 的结果:
    • sizeof(a) 是数组整体大小,等于 数组长度 × 单元素大小。
    • sizeof(&a) 是指针大小,通常是 4 或 8 字节。
  3. 地址运算步长:
    • a + 1 或 &a[0] + 1,步长是单个元素的大小(sizeof(int))。
    • &a + 1,步长是整个数组的大小(sizeof(a))。

通过这些例子可以清楚地理解一维数组在指针操作中的差异,更好地避免误用。

二维数组指针的区别

注意与一维指针类比区别开来。

指针有减法和比较运算,没有加法运算。

#include <iostream>
using namespace std;
#define sz(type) cout<<sizeof(type)<<endl;
int main(){
  int a[2][3]={
    {12,13,14},
    {112,113,114}
  };
  sz(a);
  sz(a[0]);
  sz(a[0][0]);
  cout<<a<<endl;
  cout<<&a[0]<<endl;
  cout<<a[0]<<endl;
  cout<<&a[0][0]<<endl;
  
  cout<<endl;//步长是三个元素的数组的长度
  cout<<"a: "<<a<<" "<<a+1<<endl;           //a = &a[0]
  cout<<"&a[0]:"<<&a[0]<<" "<<&a[0]+1<<endl;

  cout<<endl;//步长是一个int
  cout<<"a[0]: "<<a[0]<<" "<<a[0]+1<<endl;  //a[0] = &a[0][0]
  cout<<"&a[0][0]: "<<&a[0][0]<<" "<<&a[0][0]+1<<endl;

  cout<<endl;
  cout<<"&a: "<<&a<<" "<<&a+1<<endl;//步长是二维数组的长度
  return 0;
}

这段代码分析了二维数组中的指针及其不同地址步长的含义。以下从二维数组的本质入手,结合代码详细解析指针在二维数组中的行为及其与一维数组的区别。


二维数组指针核心概念

1. 二维数组的内存布局

二维数组本质上是连续的内存块,可以看成是若干行一维数组的集合。
例如,int a[2][3] 表示有两行,每行三个整型元素。

a[2][3] = { {12, 13, 14}, {112, 113, 114} }
内存布局: [12, 13, 14, 112, 113, 114]
  • a[i] 是指向第 i 行(即一维数组)的指针。
  • a[i][j] 是指向第 i 行第 j 列的具体元素。

2. 各指针的含义
表达式含义类型
a二维数组首地址,等价于 &a[0]int (*)[3]
a[0]第一行首地址,等价于 &a[0][0]int*
&a[0]第一行的地址(整体的地址)int (*)[3]
&a[0][0]第一行第一个元素的地址int*
&a整个二维数组的地址int (*)[2][3]

3. 步长的区别
  • a 或 &a[0] 的步长: sizeof(a[0]),即一行的大小,等于 3 × sizeof(int)。
  • a[0] 或 &a[0][0] 的步长: sizeof(int),即单个元素的大小。
  • &a 的步长: sizeof(a),即整个二维数组的大小,等于 2 × 3 × sizeof(int)。

代码解析与输出

1. 使用 sizeof 查看大小
sz(a);       // 整个二维数组的大小: 2 × 3 × sizeof(int) = 24(假设 int 是 4 字节)
sz(a[0]);    // 一行的大小: 3 × sizeof(int) = 12
sz(a[0][0]); // 单个元素的大小: sizeof(int) = 4

输出:

24
12
4

2. 各指针的地址输出
cout << a << endl;          // 等价于 &a[0],指向第一行
cout << &a[0] << endl;      // 等价于 a
cout << a[0] << endl;       // 等价于 &a[0][0],指向第一行首元素
cout << &a[0][0] << endl;   // 第一行首元素地址

输出:

0x9ffdb4  // 数组首地址
0x9ffdb4  // 等价于 &a[0]
0x9ffdb4  // 第一行首元素地址
0x9ffdb4  // 第一行首元素地址

3. 步长分析
(1) a 和 &a[0] 的步长
cout << "a: " << a << " " << a + 1 << endl;
cout << "&a[0]:" << &a[0] << " " << &a[0] + 1 << endl;
  • a + 1 或 &a[0] + 1:跳过一行,步长是 3 × sizeof(int)。

输出:

a: 0x9ffdb4 0x9ffdc0  // 步长是12字节(一行大小)
&a[0]: 0x9ffdb4 0x9ffdc0
(2) a[0] 和 &a[0][0] 的步长
cout << "a[0]: " << a[0] << " " << a[0] + 1 << endl;
cout << "&a[0][0]: " << &a[0][0] << " " << &a[0][0] + 1 << endl;
  • a[0] + 1 或 &a[0][0] + 1:跳过一个元素,步长是 sizeof(int)。

输出:

a[0]: 0x9ffdb4 0x9ffdb8  // 步长是4字节(一个int大小)
&a[0][0]: 0x9ffdb4 0x9ffdb8
(3) &a 的步长
cout << "&a: " << &a << " " << &a + 1 << endl;
  • &a + 1:跳过整个二维数组,步长是 sizeof(a)。

输出:

&a: 0x9ffdb4 0x9ffdd8  // 步长是24字节(整个数组大小)

与一维数组的区别

属性一维数组二维数组
数组名类型int*int (*)[列数]
a + 1 步长一个元素大小一行的大小
&a + 1 步长整个数组大小整个二维数组的大小
行地址不适用&a[行号] 表示行的整体地址
元素地址&a[索引]&a[行号][列号] 表示元素地址

总结

  1. 二维数组的数组名:a 是指向第0行的指针,类型为 int (*)[列数],步长是单行大小。
  2. 行与元素的指针:
    • a[i] 是指向第 i 行首元素的指针,类型为 int*。
    • &a[i] 是第 i 行整体的地址,类型为 int (*)[列数]。
  3. 地址运算步长:
    • a + 1 或 &a[0] + 1 跳过一行,步长是 列数 × 元素大小。
    • &a + 1 跳过整个二维数组,步长是 行数 × 列数 × 元素大小。

指针作为函数的参数

https://blog.csdn.net/ykm0722/article/details/7031387

使用swap(交换两个变量的值)作为演示,实现Swap的四种方法。当数组名作为函数的参数来传递的时候,他的高贵的数组结构特性已经失去了,成了一个地地道道的只拥有4个字节的平民。

#include <iostream>
using namespace std;
#define SWAP(a, b, temp) (temp=a, a=b, b=temp);
void func(int *x, int *y){
  int z=*x;
  *x=*y;
  *y=z;
}
void func1(int &x, int &y){
  cout<<x<<" "<<y<<endl; 
  int z=x;
  x=y;
  y=z;
}
template<class T>
void Swap(T &a, T&b){
  T temp=a;
  a=b;
  b=temp;
}
int main(){
  float a=12.1, b=13.2;
  cout<<a<<" "<<b<<endl;

  // int c=a;
  // a=b;
  // b=c;
  float c;
  Swap(a, b);
  cout<<a<<" "<<b<<endl;
  return 0;
}

这段代码展示了使用指针作为函数参数以及多种方式实现 swap 函数的机制和细节。以下是对代码和相关概念的详细解析。


1. 多种实现 swap 的方式

(1) 宏定义实现
#define SWAP(a, b, temp) (temp=a, a=b, b=temp);
  • 使用 宏定义 的方式实现变量交换。
  • 优点:代码简单直观。
  • 缺点:
    • 缺乏类型安全性:没有检查参数类型,一旦传递复杂类型可能出错。
    • 调试困难:宏替换发生在预处理阶段,容易导致调试不便。

示例:

float a = 12.1, b = 13.2, temp;
SWAP(a, b, temp);

(2) 使用指针参数
void func(int *x, int *y){
  int z = *x;
  *x = *y;
  *y = z;
}
  • 通过指针传递变量地址,实现值交换。
  • 优点:函数可以直接操作实参的值,而非副本。
  • 缺点:调用时需要传递地址,使用稍显繁琐。

调用示例:

int a = 5, b = 10;
func(&a, &b);

(3) 使用引用参数
void func1(int &x, int &y){
  int z = x;
  x = y;
  y = z;
}
  • 通过 引用传递,实现值交换。
  • 优点:
    • 代码更简洁,调用方式与值传递类似(不需要显式取地址)。
    • 不需要额外的解引用操作,性能略优。
  • 缺点:不支持引用常量或数组。

调用示例:

int a = 5, b = 10;
func1(a, b);

(4) 使用模板
template<class T>
void Swap(T &a, T &b){
  T temp = a;
  a = b;
  b = temp;
}
  • 使用 C++模板 泛化 swap 函数,支持多种数据类型。
  • 优点:
    • 代码复用性强,适用于任何支持赋值操作的类型(如整型、浮点型、类对象等)。
    • 类型安全。
  • 缺点:略增加编译时间。

调用示例:

float a = 12.1, b = 13.2;
Swap(a, b);

2. 特殊点:数组名作为函数参数

在 C++ 中,数组名作为函数参数传递时,会退化为指针。以下是具体表现:

数组名的特性
  1. 数组名本质:数组名是数组首元素的地址,但它保留了数组的整体大小信息。
  2. 传递到函数中:当数组名作为参数时,它退化为普通指针,数组大小信息丢失。
示例代码
void processArray(int arr[]) {
  cout << sizeof(arr) << endl; // 输出指针大小
}

int main() {
  int arr[10] = {0};
  cout << sizeof(arr) << endl; // 输出数组大小 (40)
  processArray(arr);           // 数组退化为指针 (4或8)
}
输出
40    // 数组实际大小:10 × sizeof(int)
4     // 指针大小(32位系统)或 8(64位系统)
结论
  • 在函数内无法通过 sizeof 获取数组的长度。
  • 如果需要数组长度,通常需要显式传递数组大小作为参数。

3. 代码解析与输出

(1) 宏交换 SWAP
float a = 12.1, b = 13.2, temp;
SWAP(a, b, temp);
cout << a << " " << b << endl;

输出:

13.2 12.1

(2) 指针传递
int a = 5, b = 10;
func(&a, &b);
cout << a << " " << b << endl;

输出:

10 5

(3) 引用传递
int a = 5, b = 10;
func1(a, b);
cout << a << " " << b << endl;

输出:

10 5

(4) 模板函数
float a = 12.1, b = 13.2;
Swap(a, b);
cout << a << " " << b << endl;

输出:

13.2 12.1

总结

  1. 宏定义:代码简单,但缺乏类型安全,不推荐。
  2. 指针传递:显式操作地址,适合 C 风格代码。
  3. 引用传递:代码更现代化,推荐使用。
  4. 模板:支持泛型交换,适用于复杂类型,是最通用的方式。

通过这些实现方式,可以灵活选择适合需求的方案,同时理解数组在函数参数中退化为指针的行为,有助于写出更清晰、可靠的代码。

指针作为返回值

要作为返回值,必须保证调用后返回的指针不会销毁,否则就是野指针。

#include <iostream>
using namespace std;

int a[3]; // 全局数组,自动初始化为0

int* func() {
  return a; // 返回全局变量的地址
}

int main() {
  int a = 1; // 局部变量
  cout << func()[0] << " " << func()[1] << endl;
  return 0;
}

这段代码主要展示了指针作为函数返回值的机制,并且提到了一个非常关键的问题——返回指针的生命周期。以下是详细解析。


1. 指针作为返回值的关键点

  • 指针返回值是函数返回一个地址,调用者可以通过这个地址访问存储在该位置的值。
  • 安全性问题:如果返回的指针指向了函数的局部变量,则在函数返回后,该局部变量会被销毁,导致指针成为野指针,可能引发不可预期的错误。

2. 示例代码解析

2.1 全局数组的特点
  1. 全局变量的生命周期
    • 全局变量的生命周期贯穿整个程序运行周期,直到程序结束才会被销毁。
    • 因此返回全局变量的地址是安全的,不会出现野指针。
  2. 全局数组的初始化
    • 如果没有显式赋值,全局数组中的元素会被初始化为 0(默认值)。
    • 这里 int a[3] = {0, 0, 0}。

2.2 函数 func() 的返回值
  • func() 返回全局数组 a 的首地址。
  • 在主函数 main() 中,通过 func() 可以访问全局数组的内容。
  • 优点:返回全局数组的地址是安全的。
  • 缺点:如果多个地方修改了同一全局变量,会导致数据不可预测。

2.3 局部变量作为返回值的风险

以下是一个反面例子:

int* unsafeFunc() {
  int localVar = 42; // 局部变量
  return &localVar;  // 返回局部变量地址
}

调用时:

int* ptr = unsafeFunc();
cout << *ptr << endl; // 未定义行为
  • 问题:
    • localVar 是函数的局部变量,在函数返回时,它会被销毁。
    • 返回的地址指向一个已经被释放的内存区域,结果是未定义行为。

2.4 全局变量的安全返回

代码:

int* func() {
  return a;
}
  • 安全性:返回的是全局数组的地址,不会有生命周期问题。
  • 数据访问:
    • func()[0] 等价于访问全局数组 a[0]。
    • 默认值 0 会被输出。

3. 输出结果

int a[3]; // 全局数组,初始化为 {0, 0, 0}
int main() {
  cout << func()[0] << " " << func()[1] << endl;
  return 0;
}

输出结果:

0 0

4. 常见场景及建议

4.1 返回全局变量指针

适用场景:

  • 需要函数返回一个共享的全局数据结构。
  • 确保所有访问点都使用相同的全局数据。

注意:

  • 全局变量的使用需要小心,容易导致代码耦合高、可维护性低。

4.2 返回动态分配的内存

如果需要函数动态生成数据,可以使用动态分配:

int* createArray() {
  int* arr = new int[3]{1, 2, 3}; // 动态分配数组
  return arr;                     // 返回数组首地址
}

int main() {
  int* arr = createArray();
  cout << arr[0] << " " << arr[1] << " " << arr[2] << endl;
  delete[] arr; // 使用完毕释放内存
  return 0;
}

优点:

  • 数据独立于函数栈帧,生命周期可控。
  • 灵活性高,可在堆上存储大数据。

注意:

  • 调用者负责释放动态分配的内存,否则可能导致内存泄漏。

4.3 返回局部静态变量的指针

静态变量具有全局生命周期,但作用域受限于定义所在的函数。

int* func() {
  static int localStaticVar = 42;
  return &localStaticVar; // 返回局部静态变量地址
}

int main() {
  int* ptr = func();
  cout << *ptr << endl; // 安全访问
  return 0;
}

优点:

  • 静态变量不会被销毁,返回地址是安全的。
  • 避免了全局变量的污染。

5. 总结

  1. 返回值类型分析:
    • 全局变量:安全,但可能引入全局状态问题。
    • 局部变量:危险,容易导致野指针。
    • 动态分配内存:安全,但需手动管理内存。
    • 静态变量:安全,但需注意多线程安全问题。
  2. 建议:
    • 尽量避免使用全局变量。
    • 优先考虑返回动态分配的内存或局部静态变量。
    • 在多线程环境下,需注意同步访问问题。

通过理解指针生命周期和作用域,能更好地写出健壮和高效的代码。

字符数组指针

1、str和p是不相同的!!

#include <iostream>
#include <cstring>

int main() {
  char str[3]="ab";
  char *p=str;//此处可以修改str,因为str只是字符数组(使用了字符串字面量来初始化str),但是并不是常量
  size_t length = std::strlen(str);//遇到'\0'才会停止计数
  // 例如 char a[3]={'a', 'b', 'c'}, 使用strlen后的长度不是3!!!
  printf("%c-%s-%ld-%ld\n", *str, str, sizeof(str), strlen(str));
  // sizeof(str) 返回的是数组占用的内存大小,而 strlen(str) 返回的是字符串的长度。
  printf("%c-%s-%ld-%ld\n", *p, p, sizeof(p), strlen(p));
  // sizeof(p) 返回的是int型指针占用的内存大小,而 strlen(p) 返回的是字符串的长度。
  *p='A';
  *(p+1)='B';
  std::cout<<*str<<*(str+1)<<std::endl;
  
  return 0;
}

2、此处会有一个warning,因为“ab”是存储在常量区域的,不能修改,在使用时需要使用const来申明

#include <iostream>
#include <cstring>

int main() {
  char *p="ab";// 先在常量区保存好"ab",然后在栈区建立一个char *
  //   const char *p="ab";
  printf("%c-%s-%ld-%ld\n", *p, p, sizeof(p), strlen(p));
  // sizeof(p) 返回的是int型指针占用的内存大小,而 strlen(p) 返回的是字符串的长度。
  *p='A';
  *(p+1)='B';
  std::cout<<*p<<*(p+1)<<std::endl;
  
  return 0;
}

3、此处会显示error: assignment of read-only location ‘* p’

#include <iostream>
#include <cstring>

int main() {
  const char *p="ab";
  printf("%c-%s-%ld-%ld\n", *p, p, sizeof(p), strlen(p));
  // sizeof(p) 返回的是int型指针占用的内存大小,而 strlen(p) 返回的是字符串的长度。
  *p='A';
  *(p+1)='B';
  std::cout<<*p<<*(p+1)<<std::endl;
  
  return 0;
}

4、字符数组指针的初始化

#include <iostream>
#include <cstring>
using namespace std;
int main() {
  char a='a';
  char b='b';
  char *p=&a;

  char c[]={a, b, 'c'};
  printf("%p--%p--%c--%c\n", &a, &b, a, b);
  printf("%p--%p--%c--%c\n", c, c+1, *c, *(c+1));
  char *p2[]={&a, p, c};
  for(int i=0; i<3; i++){
    printf("%p--%p--%c\n", &p2[i], p2[i], *p2[i]);
  }
  return 0;
}

函数指针

主要要把指针括起来

#include <iostream>
using namespace std;
void func(){
  cout<<"func"<<endl;
}

int add(int a, int b){
  return a+b;
}
int main(){
  int a=123;
  int *p=&a;
  printf("%p--%p\n", &a, p);

  //无参
  void (*pFunc)()=&func;//要不要&,都可
  printf("%p--%p\n", func, pFunc);

  //带参
  int (*pFunc1)(int, int)=&add;
  printf("%p--%p\n", add, pFunc1);
  return 0;
}

函数指针数组

#include <iostream>
using namespace std;
void func(){
  cout<<"func"<<endl;
}

int add(int a, int b){
  return a+b;
}
int sub(int a, int b){
  return a - b;
} 
int mul(int a, int b){
  return a*b;
}
int div11(int a, int b){
  return a/b;
}
int main(){
  int a=1;
  int b=2;
  int *p=&a;
  printf("%p--%p\n", &a, p);

  int (*pFunc[4])(int, int)={add, sub, mul, div11};
  for(int i=0; i<4; i++){
    cout<<(*pFunc[i])(a, b)<<endl;
  }
  return 0;
}

函数指针深度辨析

#include <iostream>
using namespace std;
void func(){
  cout<<"func"<<endl;
}

int add(int a, int b){
  return a+b;
}
int main(){
  void (*pFunc)()=&func;
  printf("%p\n", &pFunc);
  printf("%p\n", pFunc);
  printf("%p\n", *pFunc);
  printf("%p\n", **pFunc);
  printf("%p\n", ***pFunc);

  printf("----------\n");
  printf("%p\n", &func);
  printf("%p\n", func);
  printf("%p\n", *func);
  printf("%p\n", **func);
  printf("%p\n", ***func);


  return 0;
}

这段代码试图对函数指针的使用进行深度探索,并分析各种形式下的打印结果。然而,这里涉及到一些误用和未定义行为,下面是详细的解析。


1. 函数指针的基本概念

  • 函数指针是一种特殊的指针,用于存储函数的入口地址。

  • 定义函数指针的语法:

    返回值类型 (*指针名)(参数列表);
    

    示例:

    void (*pFunc)(); // 定义一个返回值为void,参数为空的函数指针
    

2. 示例代码解析

代码片段:

void func() {
  cout << "func" << endl;
}

int add(int a, int b) {
  return a + b;
}

int main() {
  void (*pFunc)() = &func;
  printf("%p\n", &pFunc);   // 打印函数指针变量的地址
  printf("%p\n", pFunc);    // 打印函数的入口地址
  printf("%p\n", *pFunc);   // 正确调用:实际上是调用了函数
  printf("%p\n", **pFunc);  // 错误:未定义行为
  printf("%p\n", ***pFunc); // 错误:未定义行为

  printf("----------\n");
  printf("%p\n", &func); // 打印函数的入口地址(与 pFunc 相同)
  printf("%p\n", func);  // 打印函数的入口地址(与 &func 相同)
  printf("%p\n", *func); // 错误:未定义行为
  printf("%p\n", **func); // 错误:未定义行为
  printf("%p\n", ***func); // 错误:未定义行为

  return 0;
}

3. 逐行解析与结果

3.1 第一部分:pFunc 的打印
void (*pFunc)() = &func;
printf("%p\n", &pFunc); // 打印函数指针变量 pFunc 的地址
printf("%p\n", pFunc);  // 打印函数的入口地址
printf("%p\n", *pFunc); // 函数调用,实际输出 "func"
printf("%p\n", **pFunc); // 错误:未定义行为
printf("%p\n", ***pFunc); // 错误:未定义行为
  • &pFunc:打印的是指针变量 pFunc 的地址(不是函数的地址)。

  • pFunc:打印的是函数 func 的入口地址,和 &func 相同。

  • *pFunc

    :

    • 函数指针解引用后实际是调用该函数,即会输出 "func",但不能使用 %p 打印返回值。
    • %p 是打印指针地址,而函数返回值类型是 void,这会导致未定义行为。
  • **pFunc 和 ***pFunc

    :

    • 解引用次数超出函数指针的定义范围,属于未定义行为。

3.2 第二部分:func 的打印
printf("%p\n", &func); // 打印函数的入口地址
printf("%p\n", func);  // 打印函数的入口地址
printf("%p\n", *func); // 错误:未定义行为
printf("%p\n", **func); // 错误:未定义行为
printf("%p\n", ***func); // 错误:未定义行为
  • &func 和 func:对于函数名 func,它既表示函数入口地址,也是函数指针常量。

  • *func、**func 和 ***func

    :

    • 函数名不能被多次解引用,尝试这样操作会导致编译错误或未定义行为。

4. 函数指针的正确使用方式

4.1 使用函数指针调用函数
void func() {
  cout << "This is func" << endl;
}

int main() {
  void (*pFunc)() = func;  // 函数指针指向函数
  pFunc();                 // 使用函数指针调用函数
  (*pFunc)();              // 解引用后调用(等价于 pFunc())

  return 0;
}
4.2 函数指针作为参数
int add(int a, int b) {
  return a + b;
}

int subtract(int a, int b) {
  return a - b;
}

// 函数指针作为参数
int calculate(int (*operation)(int, int), int x, int y) {
  return operation(x, y);
}

int main() {
  cout << calculate(add, 5, 3) << endl;      // 输出 8
  cout << calculate(subtract, 5, 3) << endl; // 输出 2

  return 0;
}
4.3 函数指针作为返回值
int add(int a, int b) {
  return a + b;
}

int subtract(int a, int b) {
  return a - b;
}

int (*getOperation(bool isAdd))(int, int) {
  return isAdd ? add : subtract; // 返回函数指针
}

int main() {
  int (*operation)(int, int) = getOperation(true); // 返回 add
  cout << operation(5, 3) << endl;                 // 输出 8

  operation = getOperation(false); // 返回 subtract
  cout << operation(5, 3) << endl; // 输出 2

  return 0;
}

5. 总结

5.1 函数指针的特性
  1. 函数指针存储函数入口地址,可用于动态调用。
  2. 解引用函数指针后可以调用函数,但额外多次解引用是未定义行为。
  3. 函数名本身可以隐式转换为函数指针。
5.2 打印函数指针
  • %p 适用于打印函数指针地址或函数入口地址。
  • 解引用函数指针后不能直接打印,解引用后应调用函数。
5.3 函数指针的用法
  • 函数指针常用于回调机制、动态选择操作、简化代码结构。
  • 小心未定义行为(如多次解引用、返回局部指针等)。

通过合理使用函数指针,可以提高代码的灵活性和可扩展性。

结构体内存对齐

#include <iostream>
using namespace std;

#define sz(type) cout<<sizeof(type)<<endl;
struct stu{
  char c;
  short a;
  int *b;
};//8
struct stu1{
  char c;
  int *b;
  short a;
};//12
struct stu2
{
  double a;
  char b;
  int *c;
};//16
struct stu3
{
  char b;
  double a;
  int *c;
};//24

int main(){
  sz(stu);
  sz(stu1);
  sz(stu2);
  sz(stu3);
  return 0;
}

结构体指针

#include <iostream>
#include <cstring>
using namespace std;

struct Stu{
  int a;
  char c[13];
};
int main(){
  Stu s;
  s.a=12;
  strcpy(s.c, "121");
  cout<<sizeof(s)<<endl;
  cout<<s.a<<"--"<<s.c<<endl;

  Stu *pStu=(Stu *)malloc(sizeof(Stu));
  pStu->a=11;
  strcpy(pStu->c,"qwe");
  cout<<pStu->a<<"---"<<pStu->c<<endl;
  return 0;
}

这段代码演示了 结构体指针的基本用法,以及通过 malloc 动态分配内存来操作结构体的一个实例。以下是代码的分步解析:


1. 代码运行及输出

1.1 静态分配的结构体
Stu s;
s.a = 12;
strcpy(s.c, "121");
cout << sizeof(s) << endl;
cout << s.a << "--" << s.c << endl;
  • Stu 结构体内存布局(假设 64 位系统):

    int a       -> 4 字节
    char c[13]  -> 13 字节
    填充        -> 3 字节(以满足 4 字节对齐)
    总大小      -> 20 字节
    
  • sizeof(s) 输出:20(总大小包含对齐后的填充字节)。

  • s.a 和 s.c 的值:分别为 12 和字符串 "121"。

1.2 动态分配的结构体
Stu *pStu = (Stu *)malloc(sizeof(Stu));
pStu->a = 11;
strcpy(pStu->c, "qwe");
cout << pStu->a << "---" << pStu->c << endl;
  • 动态分配了大小为 sizeof(Stu) 的内存块。
  • 使用箭头操作符 (->) 对结构体的成员进行赋值和访问。
  • 输出:11---qwe。

2. 关键知识点

2.1 结构体的静态分配
  • 定义 Stu s; 会在栈上分配内存,其生命周期由当前作用域决定。

  • 通过点操作符 (.) 访问和操作结构体的成员。

  • 对齐填充 :

    • 为了提高 CPU 访问效率,系统通常要求结构体成员对齐到其最大类型大小的倍数(此处为 4 字节)。
    • char c[13] 后需要填充 3 字节,确保结构体总大小为 4 的倍数。

2.2 结构体的动态分配
  • 使用 malloc 分配内存时,内存是从堆上分配的,生命周期由程序员手动控制(需注意释放内存以防止内存泄漏)。
  • 动态分配的结构体需要通过 指针访问,使用箭头操作符 (->) 访问成员。
2.3 内存管理注意事项
  1. 动态分配的内存需要释放:

    free(pStu);
    

    否则会造成内存泄漏。

  2. 避免使用未初始化的内存: 动态分配后,内存中的值是未定义的,需显式赋值或初始化。

    Stu *pStu = (Stu *)malloc(sizeof(Stu));
    memset(pStu, 0, sizeof(Stu));  // 初始化为 0
    
  3. 使用 malloc 时注意类型转换: 在 C++ 中,最好使用 new 而不是 malloc:

    Stu *pStu = new Stu;
    delete pStu;
    

    或者可以使用现代的智能指针来管理动态内存,避免手动释放的麻烦。


3. 输出结果(假设 64 位系统)

运行程序时会得到如下输出:

20
12--121
11---qwe

4. 推荐改进

4.1 替换 malloc

C++ 提供了更安全的内存分配方法,可以用 new 替换 malloc:

Stu *pStu = new Stu;
pStu->a = 11;
strcpy(pStu->c, "qwe");
cout << pStu->a << "---" << pStu->c << endl;
delete pStu;
4.2 使用智能指针

使用 std::unique_ptr 或 std::shared_ptr 来管理动态分配的结构体:

#include <memory>

std::unique_ptr<Stu> pStu = std::make_unique<Stu>();
pStu->a = 11;
strcpy(pStu->c, "qwe");
cout << pStu->a << "---" << pStu->c << endl;

这样可以自动释放内存,无需手动调用 delete 或 free。


5. 总结

  1. 动态分配的内存需手动管理,推荐使用现代 C++ 的 new/delete 或智能指针代替 malloc/free。
  2. 结构体的大小受对齐规则影响,可以通过调整成员顺序减少填充字节。
  3. 对动态分配的结构体指针,尽量初始化,避免出现未定义行为。
CPP14共享指针对象作为类属性要避免该类的析构无法被激活 前一段时间,有一次使用CPP共享指针掉进了调用者和被调用者,互相等待对方被释放的loop陷阱,现记录下来,防止类似错误再次发生。 条件: 假设有两个class, A和B,B是A的组成部分。 A把自己作为共享指针传给B,供B使用。 情况: A的调用者,把A对象的引用全部释放后,A对象的引用计数还剩下1,这个“1”就是B还存放着A的共享指针。 结果: A对象的析构永远无法被执行,即A对象无法被释放。 原因: A对象使用B对象,同时也被B对象使用,它们互相等待对方的共享指针使用计数跌到0,但是这个 阅读详情

相关推荐

c/cpp指针详解

通过不同的方面详细的讲解了指针的各种用法

CPP 基础篇4-指针

空指针野指针 下面代码是可以编译通过的,但是运行报错 总结:空指针 和野指针都不是我们申请的内存空间,因此轻易不要访问它指针-const修饰指针 常量指针指针常量 技巧:看const右侧紧跟着的是指针还是常量,是指针就是常量指针,是常量就是指针常量。const在*前面 常量指针 (常量的指针,常量在前,指针指向的值不能修改)*在const前面 指针常量 (指针的常量,指针在前,指针的指向不能修改)指针和数组 总结:如果不想修改实参,就用值传递,如果想修改实参,就用地址传递

wade1010的专栏 1415

高效静音黑科技 —— 单相直流无刷电机驱动器

然而,传统的BLDC电机驱动通常依赖于三相架构,电路复杂,成本高昂,且在低功率应用中显得有些“大材小用”。单相直流无刷电机驱动器作为一项高效、静音、经济的技术,正逐渐改变着各个领域的电机驱动方式。其精巧的控制策略、显著的优势以及广阔的应用前景,都预示着这项技术将在未来扮演越来越重要的角色。它相较于传统的三相驱动,显著简化了电路结构,降低了成本,尤其适用于低功率、对静音要求极高的应用场景。通过这些模块的协同工作,单相直流无刷电机驱动器能够实现对电机速度、扭矩的精确控制,并最大程度地降低噪声和振动。

wen8789的博客 1776

CPP入门08:指针

数据类型 * 变量名;* 指针变量:解引用,使用指针指向的数据。//定义一个指针变量 数据类型 * 指针变量名;int a = 1;int* p;//让指针记录变量a的地址,&为取地址符号p = &a;//打印地址cout

Heisenburg_JauZ的博客 955

粒子滤波在基于误差状态量的INS/GNSS组合导航中的使用技巧-On Particle Filter based Error-State INS/GNSS Intergrated Navigation

本文面向以15维惯导(INS)误差为状态量,3维位置误差为量测量的INS/GNSS组合导航系统,​在西工大严恭敏老师的开源工具箱中PF相关库函数基础上实现基于粒子滤波(PF)的惯导误差状态量的递推估计,设计了粒子重置环节并强调了其在本特定场景下的重要性。

I33D33I的博客 1746

R分析|怎么样使用piecewiseSEM构建结构方程模型?保姆级教程

计算科学的发展让我们有了更先进的工具揭示自然规律。结构方程模型(SEM)已被广泛应用于多学科进行数据挖掘。其中在R中实现的结构方程模型是方便快捷的。今天要介绍的piecewiseSEM包就是R中实现SEM的一种方式。piecewiseSEM被开发出来主要目的是为了解决复杂模型简化后进行分段分析。个人认为最大的特点是更灵活,且采用的是原始数据,并不是传统的协方差矩阵。其次,将SEM破碎化为多个独立的方程,对样本量要求较少。

weixin_46814750的博客 6963

CPP指针

CPP指针

你好 2081

用Python+PyTorch实现DQN无人机避障:从环境搭建到实战训练(附完整代码)

本文详细介绍了如何使用Python和PyTorch框架,基于深度强化学习中的DQN算法,实现一个无人机自主避障系统。内容涵盖从自定义环境搭建、DQN智能体核心算法实现,到完整的训练流程与超参数调优,并提供了可视化演示与进阶优化方向,为开发者提供了从理论到实践的完整指南。

kubernetes8ctl的博客 642

Cpp 指针常见用法(2021-06-13)

Cpp poniter再回顾 C++的指针的正确理解:指针是一种特殊的变量,该变量存放的是内存地址。 1、用于变量 变量指针常用在函数的形参中,如经典的swap函数,用于交换两个变量的值。 #include<iostream> void swap(double* a,double* b) { double temp = *a; *a = *b; *b = temp; } int main(int argc, char** argv) { double a, b; a = 1, b

weixin_43725312的博客 1661

京东运维面试题及参考答案

cgroup(Control Group)是 Linux 内核提供的一种可以限制、控制与分离一个进程组群的资源(如 CPU、内存、磁盘 I/O 等)的机制。通过 cgroup,可以为不同的进程或进程组分配特定的资源配额,实现资源的隔离和管理。比如,在一个服务器上运行多个容器时,可以使用 cgroup 来限制每个容器对 CPU 和内存的使用,防止某个容器占用过多资源而影响其他容器的运行。cgroup 还可以对进程进行优先级设置,确保关键进程能够优先获得资源。

大模型大数据攻城狮的专栏 1243

OpenTK简介

OpenTK 因其强大的功能、跨平台特性和灵活性,适用于多种需要图形和计算能力的应用场景,为开发者提供了丰富的可能性和创作空间。

仰望星空的博客 1986

【CPP】指针

const int * const: 既不可以修改指针指向的内容也不可以修改指针本身。int * const: 不可以修改指针本身(地址)const int *: 不可以修改指针指向的内容。第一次申请的内存丢失了,无法管理也无法销毁。不能将const 的指针赋值给普通指针。

weixin_38362786的博客 638

把个人化的 SQVI 报表变成可维护、可共享、可传输的 ABAP Query:从定位来源到转换落地的完整路线图

本文针对SAP系统中业务用户常用但难以维护的SQVI临时报表问题,提供了一套完整的解决方案。文章首先区分了SQVI(个人临时报表)和ABAP Query(团队可维护报表)的关键差异,重点介绍了如何通过函数模块RSAQ_DECODE_REPORT_NAME反查报表来源。对于SQVI报表,详细说明了定位创建人和转换为团队可维护的ABAP Query的具体步骤,包括Query Area切换、转换操作和后续维护方法。最后总结了常见问题的解决方案,如字段调整、口径固化和生成程序名反查等,为现场实施提供了可直接操作的完

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 305

C/C++指针深析

指针对于初学者往往是很难以琢磨的东西,因为它并不如变量那么抽象,而是更贴近底层的真实结构。指针操作往往会出现各种各样的岔子,最常见的便是”segmentation fault”。

m0_67623521的博客 546

使用GBIF获取生物多样性数据与GIS的结合

随着全球生物多样性的重要性日益凸显,越来越多的研究人员和保护机构开始利用地理信息系统(GIS)来分析和可视化生物多样性数据。GBIF(全球生物多样性信息设施)作为一个全球性的生物多样性数据库,提供了大量的物种分布和分类信息,为研究人员和保护工作者提供了宝贵的数据资源。本文将介绍如何使用GBIF API获取生物多样性数据,并将其与GIS技术相结合,以便更好地理解和研究生物多样性。利用GIS的强大功能,我们可以在地理空间上可视化物种分布、分析物种多样性的空间格局,并为保护生物多样性提供科学依据。

BnxBackend的博客 1765

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

快速理解上手并实践:深析C++内存模型与智能指针的有效使用

作为一名致力于简化复杂技术、助您快速上手实践的博主,本文将带您深入浅出地理解C++内存模型的核心概念,掌握智能指针的正确用法,并通过实战代码示例演示如何避免常见的内存管理问题。后续文章中,我们将进一步探讨更复杂的内存管理场景和智能指针的高级用法,帮助您深化理解并提升技能。智能指针是C++标准库提供的内存管理利器,它们在构造时自动分配内存,在析构时自动释放内存,有效防止内存泄漏。std::shared_ptr: 共享所有权,引用计数管理,多个智能指针可同时指向同一块内存,当最后一个引用消失时自动释放。

zevjay的博客 496

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

C++ 笔记 深赋值 浅赋值(面向对象)

C++ 中,当使用运算符将一个对象赋值给另一个同类型对象时,会调用拷贝赋值运算符。若我们不手动定义,编译器会自动生成一个默认拷贝赋值运算符,这是浅赋值的源头;浅赋值与深赋值,本质是拷贝赋值运算符对对象成员的两种不同处理方式。浅赋值是逐字节拷贝对象的成员变量:对于普通成员(int、char 等)直接拷贝值;对于指针成员,仅拷贝指针存储的内存地址不拷贝指针指向的实际数据。深赋值是手动重载拷贝赋值运算符:对于指针成员,先分配一块独立的新内存,再将原指针指向的数据拷贝到新内存中。最终两个对象的指针成员指向。

堇荼如饴风禾尽起~ 510

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

c++——浅拷贝和深拷贝、浅赋值和深赋值

深拷贝与浅拷贝、深赋值和浅赋值

2301_79310249的博客 1216

C++的类字符串和浅深赋值问题

C++的类字符串和浅深赋值问题

little_startoo的博客 182

C++避坑指南-复制相同指针重复释放问题

介绍了C++复制构造后持有同一指针造成析构时重复释放问题及解决方法

xiaoqiang321的专栏 824

C++中的虚析构

首先什么是虚析构,虚析构就是析构函数为虚函数。 那么为什么要用虚析构呢,是为了delete基类指针指向派生类时防止子类得数据不会被释放造成内存泄露。 我们看一下下面的例子: 首先我们定义一个数据类,MyData class MyData { public: MyData(){ m_Data = new char[10]; } ~MyData() { delete[] m_Data; ...

不会飞的纸飞机的博客 9170

c++ 虚析构的作用以及成员变量为指针和普通数据成员在析构时的不同

一、派生类指针指向父类时父类的虚构函数必须设置为虚函数 看下面的代码: class Data { public: Data(int data) { a = data; cout << "Data构造" << endl; } ~Data() { cout << "~Data析构" << endl; } private: in...

struggle6688的专栏 919

C++ 容器中存入”指针“及对象析构问题

[转]C++ 容器中存入”指针“及对象析构问题  (2012-09-20 23:32:20) 转载▼ 标签:  杂谈 分类: C相关 【转自】:http://blog.sina.com.cn/s/blog_4b3c1f950100kgps.html 一般地当我们只想知道一个值是否存在时,set 最有用处;希望存储也可能修

jfkidear的专栏 1万+

秒懂C++之this指针、构造、析构

本篇文章全程高能,不仅讲解了this指针的隐藏面目还为大家详细讲解了构造函数与析构函数真正的实现内核,相信大家一定会有所收获的~

fax_player的博客 1128

c++ 的 指针析构 问题

c++的指针析构问题

ken2232的博客 2163

C++子类的智能指针赋值给父类的智能指针,析构函数不是虚函数,也能正确执行析构

C++子类的智能指针赋值给父类的智能指针,析构函数不是虚函数,也能正确执行析构 正如大家都知道,如下代码片段: BaseNode *pp1 = new BinaryTreeNode(); // BaseNode 是 BinaryTreeNode的父类 delete pp1; 如果想要在delete回收pp1指针时正确析构对象,即:先执行BinaryTreeNode()函数,再执行BaseNode...

ronnie88597的博客 2449
上一篇: C++内存布局以及常用关键字
下一篇: 理解正则化来防止模型过拟合以及L1正则化的模拟过程
夜猫程序猿
博客等级 码龄6年 283粉丝 49原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夜猫程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址