day02
1.布尔
C语言使用布尔类型的方法如下
//利用宏
#include<stdio.h>
typedef int BOOL;
#define TRUE 1
#define FALSE 0
int main()
{
BOOL bVal = TRUE;
bVal = FALSE;
bVal = 8;//可读性差
}
c++中直接使用 bool，如下
//利用关键字
int main()
{
bool bVal = true;
bVal = false;
bVal =2;//非零为真。。内存为 01
//bool只有一个字节
}
2.const
相比于C语言优化了无参宏。
宏缺点：1）没有类型检查 2)没有符号（无法调试）
const int VAL = 10000;//定义了一个常量
int main()
{
char ch = VAL;
cout << ch << endl;
*(int*)&VAL = 10;//不能更改，发在只读数据区
const int val = 1000;
*(int*)&val = 10;
cout << val << endl;//const 修饰的是常量，在编译过程中会进行替换，将val替换成1000
return 0;
}
//修饰指针防止误操作
void ShowArray(const int* pAry, int nCnt)
{
//pAry[2] = 5566;
*(int*)(pAry + 2) = 5566;//不能修改是语法层的限制
for (int i = 0; i < nCnt; i++)
{
cout << pAry[i] << " ";
}
cout << endl;
}
int main()
{
int ary[] = { 12,312,312,123,41,231 };
ShowArray(ary, sizeof(ary) / sizeof(ary[0]));
return 0;
}
const tpye* p
// const tpye* p ； p指向的内容不可以被修改，p本身可以被修改
int n = 1;
int n2 = 3;
const int* p = &n;
p = &n2;
//*p = 8;
tpye const* p
// tpye const * p ； p指向的内容不可以被修改，p本身可以被修改
int n = 1;
int n2 = 3;
int const* p = &n;
p = &n2;
//*p = 8;
tpye* const p
// const tpye* p ；p指向的内容可以被修改，p本身不可以修改。
int n = 1;
int n2 = 3;
int* const p = &n;
//p = &n2;
*p = 8;
const tpye* const p
//const tpye* const p ；p指向的内容不可以被修改，p本身不可以被修改
int n = 1;
int n2 = 3;
int const* const p = &n;
p = &n2;
*p = 8;
eg:
int nVal1 = 8;
int nVal2 = 9;
const int* p1 = &nVal1;
int const* p2 = &nVal2;
const int* const p3 = &nVal1;
const int* const p4 = p1;
const int* const p5 = p2;
//int* p6 = p1;//int*与const int*类型不匹配
//int* p7 = p3;//int*与const int*类型不匹配
const int* p8 = p3;
//int* const p9 = p3;//int*与const int*类型不匹配
//int* const p10 = p1;//int*与const int*类型不匹配
3.引用
指针的危害
//可能误用到野指针，。空指针
void Swap(int* pn1, int* pn2)
{
int nTmp = *pn1;
*pn1 = *pn2;
*pn2 = nTmp;
}
int main()
{
int n1 = 2;
int n2 = 3;
//Swap(nullptr,&n2);//报错。访问权限
int* p = (int*)malloc(4);
free(p);
//Swap(p, &n2); 使用了野指针。
}
使用引用的两数交换
void SwapXXXX(int& nRef1, int& nRef2)
{
int nTmp = nRef1;
nRef1 = nRef2;
nRef2 = nTmp;
}
int main()
{
int n1 = 2;
int n2 = 3;
SwapXXXX(n1, n2);
}
引用的基础了解
int main()
{
//引用：起别名
int n1 = 2;
int& n1Ref = n1;
int& n1Ref2 = n1;
n1Ref = 5;
n1Ref2 = 2;
}
引用与指针的区别
int main()
{
//引用与指针的区别
//int& nRef;//报错，引用必须初始化
//int n = 9;
//int& nR1 = n;
//int&& nR2 = nR1;//引用没有多级引用
//int n1 = 8;
//nR1 = n1;//引用不能改变引用的变量，这里其实是赋值语句
//int& n = 9;//应用不能引用常量
const int& n = 9;//const修饰的引用可以引用常量
}
引用适用于所有类型
#if 0
int& func()
{
int n = 9;
return n;
}
int main()
{
//int& nRef1 = func();//不要返回局部变量的引用，因为局部变量当函数使用完后会释放掉
//引用可以用于所有类型
float f = 3.21f;
float& fR = f;
fR = 8.6f;
char ch = 'a';
char& chR = ch;
chR = 'b';
struct tagTest
{
int m_n;
float m_f;
};
tagTest t;
tagTest& tR = t;
t.m_f = 6.54f;
t.m_n = 12;
int n4 = 9;
int* pn4 = &n4;
int*& pn4R = pn4;
int n5 = 98;
pn4R = &n5;
*pn4R = 69;
}
引用的本质还是指针
//通过调试查看堆栈可知道引用的本质还是指针
void SwapXXXX(int& nRef1, int& nRef2)
{
int nTmp = nRef1;
nRef1 = nRef2;
nRef2 = nTmp;
}
int main()
{
int n1 = 2;
int n2 = 4;
SwapXXXX(n1, n2);//引用本质还是指针
}
4.默认参
1.当函数调用没有提供实参的时候，会使用默认参
2.如果提供了实参，则会使用实参。
3.默认参必须从右向左依次设置，中间不能间断
4.默认参要放到声明里面，不能同时放到声明和实现中。
使用宏定义
void Say(const char* szUser, const char* szCon)
{
cout << szCon << "打招呼" << szCon << endl;
}
#define SAY(szUser) Say(szUser,"你好")
int main()
{
SAY("安安");//放在常量数据区，不可被修改
Say("啊瑟", "你好");
}
使用默认参数
void Say(const char* szUser, const char* szCon="你好")
{
cout << szCon << "打招呼" << szCon << endl;
}
int main()
{
Say("莫再提");
Say("莫再提");
Say("莫再提");
Say("西门吹雪", "吃了");
std::cout << "Hello World!
";
}
注意：一般在.h文件中定义函数声明。