C++指针和数组知识点总结（防坑指南）

一，区分字符串常量和字符串变量

字符串常量的声明方式：（存储在常量存储区，不可被修改）

char *p="I love you";

字符串变量的声明方式：（通常放在栈中，可被修改）

char p[]="I love you";

字符串常量的声明方式例子：

#include <iostream>

using namespace std;

int main()
{
	char *p = "I love you";
	p[0] = 'H';
	cout << p << endl;
	return 0;
}

输出：长时间等待后无输出，单步调试提升如下

字符串变量的声明方式例子：

#include <iostream>

using namespace std;

int main()
{
	char p[] = "I love you";
	p[0] = 'H';
	cout << p << endl;
	return 0;
}

输出：

二，注意函数传参的类型

1.使用string定义字符串，传入函数

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

void Change(string cp)
{
	cp[0] = 'H';
}

int main()
{
	string p = "I love you";

	Change(p);

	cout << p << endl;
	return 0;
}

2.使用char*定义的字符串，传入函数

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

void Change(char *cp)
{
	cp[0] = 'H';
}

int main()
{
	char p[] = "I love you";

	Change(p);

	cout << p << endl;
	return 0;
}

原因：

1，string传入的字符串：相当于string cp=p；

      此时p的是一个类对象，函数对该对象进行拷贝，形成一个新的字符串cp，而对cp的修改不会影响p。

2，char* 传入的字符串：相当于char *cp=p；

      char cp[]传入的字符串与上面相同：char cp[]=p;

      此时的p是字符串的首地址，对cp和p指向同一个存储区域，通过cp对存储区域的修改会影响p指向的字符串。

解决办法：加入引用   void Change(string &cp)

三，注意函数返回的变量类型

观察如下2个代码：

1.

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

char* Change()
{
	char p[] = "123";
	return p;
}

int main()
{
	char* q = Change();
	cout << q << endl;
	return 0;
}

2.

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

char* Change()
{
	char *p="123";
	return p;
}

int main()
{
	char* q = Change();
	cout << q << endl;
	return 0;
}

原因：

1，p[]为局部数组，函数调用完成后立即销毁，导致返回的指针找不到对象。

2，*p指向的字符串常量在静态存储区，函数调用完成后不会立即销毁，所以返回的指针可以找到对象。

解决办法：数组声明为静态数组static char p[]="123";容易被修改不推荐

C语言临时变量与临时变量指针作函数的返回值-CSDN博客

c++存储区：栈，堆，全局/静态存储区，常量区，自由存储区 参考链接：

C/C++堆、栈及静态数据区详解

static全局变量与普通的全局变量

四，static与extern的区别（声明可以有多次，定义只能一次）

static int a; 定义的变量a=0,只在当前cpp中可以使用，修改后不影响其他地方，其他地方调用的值默认为0；

                     ->当前cpp文件中全局共享

extern int a; 声明变量a;修改后影响其他地方的值，可以多处声明，但是只能在一处定义

                      ->所有cpp文件中全局共享

int a;定义的变量a=0,只在当前cpp中可以使用，其他地方无法调用，其他地方只能用extern声明后才能调用

//mian.h
#ifndef MAIN
#define MAIN
static int t;					//定义t   头文件中使用该方式不安全（假全局变量）
extern int p;					//声明p

void ou2();						//相当于extern void ou2();	
static void ou3();
class A
{
public:
	static int b;				//声明p
	//extern int c;				//非法定义
	void ou();					//使用所有变量
	static void ou4();			//只能使用全局变量
};
#endif

//main.cpp
#include <iostream>
#include "main.h"
#include <string>
using namespace std;

int p = 0;	//定义p=0
int A::b = 0;	//定义b=0
int q;	//定义b=0

int main()
{
	t = 1;
	p = 1;
	q = 1;
	A::b = 1;
	cout << "t = " << t << endl;
	cout << "p = " << p << endl;
	cout << "q = " << q << endl;
	cout << "A::b = " << A::b << endl;
	
	t = 2;
	p = 2;
	q = 2;
	A::b = 2;
	ou2();      //在其他文件定义，可以使用

	//ou3();   //静态成员函数必须在当前定义，不然无法使用

	t = 3;
	p = 3;
	q = 3;
	A::b = 3;
	A::ou4();

	t = 4;
	p = 4;
	q = 4;
	A::b = 4;
	A a;
	a.ou();
	return 0;
}

//main2.cpp
#include <iostream>
#include "main.h"
#include <string>
using namespace std;
extern int q;

void ou2()
{
	cout << "t = " << t << endl;
	cout << "p = " << p << endl;
	cout << "q = " << q << endl;
	cout << "A::b = " << A::b << endl;
}

static void ou3()
{
	cout << "t = " << t << endl;
	cout << "p = " << p << endl;
	cout << "q = " << q << endl;
	cout << "A::b = " << A::b << endl;
}

void A::ou()
{
	cout << "t = " << t << endl;
	cout << "p = " << p << endl;
	cout << "q = " << q << endl;
	cout << "A::b = " << A::b << endl;
}

 void A::ou4()
{
	cout << "t = " << t << endl;
	cout << "p = " << p << endl;
	cout << "q = " << q << endl;
	cout << "A::b = " << A::b << endl;
}

总结： static当前文件定义，当前使用

           static在类中用，等同于extern的效果

           extern当前文件声明，调用其他地方的定义

           extern无法在类中使用

如上全为个人理解，如有错误欢迎指正