03.Const使用

全局const和局部Const区别

//1. const全局和局部变量区别？
//const全局变量在常量区，不能修改(直接或者间接)
const int g_c = 100;
void test03()
{
	//直接修改不行
	//g_c = 200;

	//间接修改也不行
	int *p = (int *)&g_c;
	*p = 200;

	//全局const放在常量区，一旦初始化，不能修改
}

//2. const局部变量  在栈上
void test04()
{
	//栈上
	const int a = 100;
	//a = 200;

	int *p = (int *)&a;
	*p = 200;

	printf("a = %d\n", a);

}

const修饰指针

1.通过指针修改const修饰的常量
const int a = 10;
a = 100;//语法错误，a的值不能修改
int *p = &a;
*p = 100;
a =100; //这种可以修改指针和变量的值
可以通过1级指针修改一个常量的值

2.const修饰指针类型 int * 不能改变指针变量指向的内存地址的值 但是可以改变指针指向的地址 
const int *p = &a
p=&b
*p = 100   //语法错误
可以改变指针指向的地址

3.const修饰指针变量    能改变指针指向地址的值，但不能改变指针指向的地址
int * const p = &a;
*p = 100;
 p=&b   //语法错误
可以修改指针指向地址的值

4.const修饰指针类型修饰指针变量  不能改变指针指向的的值 也不能改变指针指向的地址 
const int * const *p = &a;
*p =100;  //语法错误
p = &b;   //语法错误

int main()
{
	int a = 10;
	//如果const修饰int *，则不能改变指针变量指向的内存地址的值，不能修改a的值,但是可以修改指针指向的地址
	const int* p;
	p = &a;
	*p = 100;//有语法错误，不能修改a的值
	int b = 20;
	p = &b;//修改p的指向，指向b，但是还是不能修改b的值
	cout << "*p修改以前的值=====" << *p << endl;
	system("pause");
	return EXIT_SUCCESS;
}

const增强

C语言中const是伪常量，可以通过指针修改，下面的输出是200，200

void test07()
{

	//m_A = 100;
	const int m_B = 20; //伪常量
	//m_B = 100;

	int * p = (int *)&m_B;
	*p = 200;
	printf("*p = %d , m_B = %d \n", *p, m_B);

	//int arr[m_B]; 不可以初始化数组

}

C++中const会放入到符号表中 ，下面的输出是200，20。因为并没有分配内存，所以值并没有修改

void test07()
{

	const int m_B = 20; //真正常量
	//m_B = 100;

	int * p = (int *)&m_B;
	*p = 200;
	cout << "*p = " << *p << endl;
	cout << "m_B = " << m_B << endl;

}

C语言中const默认是外部链接，C++中const默认是内部链接

const int a = 10; //C语言中默认const是外部链接

int main(){

	extern const int a; //告诉编译器在a在外部
	printf("a = %d \n ", a);

	system("pause");
	return EXIT_SUCCESS;
}

test.cpp中的a变量必须使用extern提高作用域才能被使用，extern const int a = 10; //C++中的const默认内部链接 ,extern提高作用域,只有上面的申明，外面才能用a

int main(){

	extern const int a;
	cout << a << endl;

	system("pause");
	return EXIT_SUCCESS;
}

const分配内存情况

对变量取地址，会分配临时内存
extern关键字下的const会分配内存
用普通变量初始化const变量
自定义数据类型会分配内存

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;

//1、const分配内存 取地址会分配临时内存
//2、extern 编译器也会给const变量分配内存
void test01()
{
	const int m_A = 10;
	int * p = (int*)&m_A; //会分配临时内存
	*p = 200;
	cout << "*p = " << *p << endl;// *p = 200
	cout << "m_A = " << m_A << endl; //m_A = 10

}

//3、 用普通变量初始化 const 的变量
void test02()
{
	int a = 10;
	const int b = a; //会分配内存

	int * p = (int *)&b;
	*p = 1000;

	cout << "b = " << b << endl;// b = 1000

}

//4、 自定义数据类型  加const也会分配内存
struct Person
{
	string m_Name; //姓名
	int m_Age;
};

void test03()
{
	const Person p1;
	//p1.m_Name = "aaa";

	Person * p = (Person*)&p1;
	p->m_Name = "LLLLLL";
	(*p).m_Age = 18;

	cout << "姓名： " << p1.m_Name << " 年龄： " << p1.m_Age << endl;
	//姓名： LLLLL      年龄：18

}


int main(){

	//test01();
	//test02();
	test03();

	system("pause");
	return EXIT_SUCCESS;
}

尽量以const替换#define

1．const有类型，可进行编译器类型安全检查。#define无类型，不可进行类型检查.
2．const有作用域，而#define不重视作用域，默认定义处到文件结尾.如果定义在指定作用域下有效的常量，那么#define就不能用。
Const可以规避地址传递的副作用---使用对象指针的时候会把数据修改。c语言的值传递太占空间

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person
{
	char name[64];
	int age;
	int ID;
	double score;
};

//规避地址传递的副作用(在使用对象指针的情况下，有可能意外修改数据)
void PrintPerson(const struct Person *person)
{

	//person->ID = 128;

	struct Person *p = (struct Person *)person;



	//p->ID = 128;

	printf("Name:%s Age:%d ID:%d Score:%f\n",person->name,person->age,person->ID,person->score);
	
}

void test()
{
	struct Person person = { "Trump", 30, 250, 59.9 };
	PrintPerson(&person);
}


int main(){

	test();

	system("pause");
	return EXIT_SUCCESS;
}