C++语言技术体系学习笔记（二）

1.4 BOOL与bool区别

BOOL本质上是一个 int 别名，bool本质上是C++关键词

BOOL定义的变量占用空间大小为4个字节，bool定义的变量占用的空间大小为1个字节

使用bool时候，要包含头文件 windows.h

BOOL b=TRUE;//本质是  typedef int BOOL    #define TRUE 1 
cout<<sizeof(b)<<" "<<sizeof(BOOL)<<endl;//4  4
//bool C++中提供的关键字，true 真，false 假
//bool 定义的变量，占用的空间大小是   1个字节
bool bb = true;
cout << bb << " " << sizeof(bool) << " " << sizeof(bb) << endl;//1  1   1

1.5 string

string 是 C++提供的字符串存储、操作的类需要包含头文件并打开std命名空间

#include <string>
using namespace std;

其天然支持字符串的初始化、赋值、比较、拼接、下标访问等操作。

string str="1234";
//下标访问 赋值
str[0]='A';
cout<<str<<endl;//A234
//赋值
str="abcd";
cout<<str<<endl;//abcd
string str2="abcd";
//比较
if(str==str2)
{
	cout<<"相等"<<endl;//相等
}
//拼接
str2+=str;
cout<<str2<<endl;//abcdabcd

字符串的截取需要用函数substr，并返回截取后的字符串。

_Myt substr(size_type _Off = 0,//字符串截取的下标，从0开始,如果下标超限则
访问越界
size_type _Count = npos) //截取的长度，如果长度超限制，则取有效长度

size() ，length() 则返回字符串的长度（字符数量）。

将string 类型转换为字符指针，用 const char *c_str()

1.6 函数重载

1）for循环

普通for循环

增强的范围for循环：new 的数组 不可以用增强的范围for去遍历、还可以遍历 支持 begin end 操作的容器

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string str="1234";
    str[0]='A';
    for(int i=0;i<str.size();i++)
    {
    	cout<<str[i]<<" ";//A 2 3 4
    }
    cout<<endl;
    
    int arr[5]={1,2,3,4，5};
    for(int i=0;i<5;i++)
    {
    	cout<<arr[i]<<" ";//1 2 3 4 5
    }
    cout<<endl;
    /*--增强的范围for循环-----------*/
    for(int v: arr)
    {
    	cout<<v<<" ";//1 2 3 4
    }
    cout<<endl;
    for(char v:str)
    {
    	cout<<v<<" ";//A 2 3 4
    }
    cout<<endl;
    //new 的数组   不可以用增强的范围for去遍历
    int* p=new int[5]{6,7,8,9,10}
    //int* p = new int[5]{ 5,6,7,8,9 };
	//for (int v ：p)//err   不知道数组的长度（p里面仅仅存的是数组的首地址，并不知道数组的长度）   无法遍历     //  返回类型   变量 ： 地址
	//{
	//	cout << v << " ";
	//}

	//还可以遍历  支持 begin  end 操作的容器
}

2）函数重载

在函数声明处，指定函数参数的默认值，在调用函数时候，未传递实参的情况下，使用的是默认值

应当在声明处指定默认值 在定义的地方指定默认值是一个无意义的操作

int add(int a=30, int b=40);
int main()
{
	cout << add(10, 20) << endl;// 传入参数，用传参计算
	cout << add() << endl;// 70   利用默认值计算
	cout << add(50) << endl;//参数从左往右传参  90
	return 0;
}
//定义
int add(int a, int b)
{
	return a + b;
}

函数重载：在同一个作用域下函数名字相同，参数列表不同（参数的类型、数量、顺序、不同），对于返回类型并未做要求（返回类型可同、可不同） 对于函数重载来说，在调用函数时候，可以根据传递的实参自动去匹配对应的函数

void fun(int)
{
	cout << "void fun(int)" << endl;
}
void fun(int,int)
{
	cout << "void fun(int,int)" << endl;
}
void fun(int,char)
{
	cout << "void fun(int,char)" << endl;
}
void fun(char,int)
{
	cout << "void fun(char,int)" << endl;
}
int main()
{
	fun(10);//void fun(int)
	fun(10, 10);//void fun(int,int)
	fun(10, 'a');//void fun(int,char)
	fun('a', 10);//void fun(char,int)
	return 0;
}

函数重载二义性问题解决方法：1、局部声明，优先级高。2通过函数指针解决。

void fun2(int)
{
	cout << "void fun2(int)" << endl;
}
void fun2(int ,int a=30)
{
	cout << "void fun2(int,int a=20)" << endl;
	cout << a << endl;
}
int main()
{
    //fun2(20);//err   出现函数二义性
    //--通过局部声明解决函数二义性
    {
        void fun2(int);
        fun2(20);//void fun2(int)
    }
    {
        void fun2(int,int a=10);//局部声明 ，优先级高
		fun2(20);//void fun2(int,int a=20)   10
    }
    //--通过函数指针解决函数二义性----------------
    void（*pfun1）(int)=&fun2;
    void(*pfun2)(int,int)=&fun2;
    (*pfun1)(20);//void fun2(int)
    (*pfun2)(20,10);//void fun2(int,int a=30)   10
}

1.7 nullptr

nullptr 与NULL 的区别：

NULL本质上是宏 替换的是 0， nullptr是关键字 NULL 含义是整型数字，nullptr含义是空指针 c++ 为什么要引入nullptr 解决 整型0 与 指针 之间的混用问题

void fun(int a)
{
	cout <<" void fun(int a) "<< a << endl;
}
void fun(int*p)
{
	cout << " void fun(int *p) " << p << endl;
}
int main()
{
	int* p = NULL;//指针在定义后若不知指向哪块空间，应当初始化为空

	fun(NULL);//void fun(int a)    0 
	fun((int*)NULL);// void fun(int *p) 00000000
    
	void fun(int* p);//局部声明
	fun(NULL);// void fun(int* p) 00000000

	//----------------------------------
	nullptr;//本质上是：关键字  含义  空指针
	fun(nullptr); //void fun(int* p) 00000000
}

void fun2(int*p)
{
	cout<<"void fun2(int*p)"<<p<<endl;
}
void fun2(char*p)
{
	if(p!=nullptr)
	{
		cout<<"void fun2(char*p)"<<p<<endl;
	}
	else 
	{
		cout<<"void fun2(char*p)"<<endl;
	}
}
int main()
{
	//通过强转方式实现
	fun2((int*)nullptr);//void fun(int* p) 00000000
	fun2((char*)nullptr);//void fun(char* p) 
	//局部声明解决函数二义性
	void fun2(int* p);
	fun2(nullptr);//void fun(int* p) 00000000
	{
		void fun2(char* p);
		fun2(nullptr);void fun(int* p) 00000000
	}
}