C++基础笔记（一）引用和对C的扩展
文章目录
- 一、C++初识
- 1.Hello World
- 2.头文件
- 二、C++对C的扩展
- 1. 双冒号作用域运算符
- 2. namespace 命名空间
- 3. using声明和using编译指令
- 4.C++对C语言增强
- 三、引用基本语法
- 1.基本语法
- 2.参数3种传递方式
- 3.引用的注意事项
- 4. 如果函数的返回值是引用，那么这个函数调用可以作为左值
- 5.引用的本质就是一个指针变量
- 6.指针的引用
- 7.常量引用
一、C++初识
1.Hello World
#include //标准输入输出流 i-in输入 o-out输出
using namespace std;//使用命名空间 std 打开一个叫std房间
//函数入口地址
int main()
{
// cout 标准的输出
// << 左移运算符
// endl 结束换行
cout << “Hello World” << endl;
system(“pause”);//阻塞功能
retrun 0;//返回正常退出
}
2.头文件
#include //c风格头文件 c++完全兼容
#include //c++风格头文件
#include //c风格头文件
#include //c++风格头文件 c++完全兼容
二、C++对C的扩展
C4996错误
添加下面的宏定义
#define CRT SECURE ND NARVINGS
1. 双冒号作用域运算符
全局作用域 直接加 ::
2. namespace 命名空间
用途 解决名称冲突问题
必须在全局作用域下声明
命名空间下可以放入 函数、变量、结构体、类…
命名空间可以嵌套命名空间
命名空间是开放的，可以随时加入新的成员
匿名命名空间 static
可以起别名
3. using声明和using编译指令
using LOL:: sunwukongID;
如果局部范围内还有 sunwukongID，会出现二义性问题，要注意避免
编译指令
using namespace LOL
如果局部范围内还有 sunwukongID ,使用局部的ID
如果打开多个房间，那么也要注意二义性问题
4.C++对C语言增强
-
全局变量增强检测
-
函数检测增强
- 函数类型检测
- 返回值检测
- 传参个数检测
-
类型转换检测增强
malloc返回void* ,C中可以不用强转，C++必须强转
//在C中不用强转
void test()
{
char *p = malloc(sizeof(64)); //malloc返回值是void*
}
//在C++中必须强转
void test()
{
char *p = (char*)malloc(sizeof(64)); //强制将malloc返回值转换为char*
}
-
struct增强
- C中不许有函数 C++可以有
- 使用C必须加关键字 struct ，C++可以不加
-
bool数据类型增强
- C没有 C++有
- true 真 false 假
- sizeof 1
-
三目运算符增强
- C中返回的是值
- C++中返回的是变量
-
const增强
- C语言中const是伪常量，可以通过指针修改
- C++中const会放入到符号表中
- C语言中const默认是外部链接，C++中const默认是内部链接（在当前文件夹内可用，外部文件夹不可用，需要用 extern 提高作用域）
- const分配内存情况
- 对变量取地址，会分配临时内存
- extern关键字下的const会分配内存
- 用普通变量初始化const变量
- 自定义数据类型会分配内存
- 尽量用const代替define
- define宏没有作用域概念
- define宏常量没有类型
三、引用基本语法
1.基本语法
- 用途起别名
相当于下面的 a, b操作同一个内存空间
int a = 200;
int &b = a; //&写到左侧，叫引用，写到右侧，取地址
// a,b都可以改变200内存空间的值
- 引用基本用法
Type &别名 = 原名
- 引用必须初始化
未初始化引用，编译器会报错，下面代码编译不通过
void test()
{
int &a;
}
- 引用初始化后不可以修改
void test()
{
//int&a，必须初始化
int a=10;
int &b=;//引用初始化后不可以修改了
int c=20;
b=c;/赋值！！！
}
- 对数组建立引用
void test()
{
int arr[10];
for(int i = 0;i < 10 ; i++)
{
arr[i]=i;
}
int (&pArr)[10] = arr;//给数组起别名
for(int i=0;i<10;i++)
{
count<< pArr[i]<<" ";
}
cout<2.参数3种传递方式
- 值传递
只是做一些逻辑的变换，不会改变传进去的值
void mySwap1(int a, int b)
{
int tmp = a;
a = b;
b= tmp;
}
void test01()
{
int a=10;
int b=20;
mySwap(a,b);//值传递
cout <<"a"=<< a <- 地址传递
会改变传进去的值
void mySwap2(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b= *tmp;
}
void test02()
{
int a=10;
int b=20;
mySwap(&a,&b);//地址传递
cout <<"a"=<< a <- 引用传递
会改变传进去的值，类似地址传递
void mySwap3(int &a, int &b) // &a = a; &b = b;
{
int tmp = a;
a = b;
b= tmp;
}
void test03()
{
int a=10;
int b=20;
mySwap(a,b);
cout <<"a"=<< a <3.引用的注意事项
- 引用必须引用一块合法的内存空间
void test()
{
int &a = 10; //引用必须引用一块合法的内存空间 (10没有内存空间)
}
- 不要返回局部变量的引用
int& doWork1()
{
int a =10;
return a;
}
void test()
{
int &ret = doWork();
cout << "ret" << ret <int& doWork2()
{
static int a =10;
return a;
}
void test()
{
int &ret = doWork();
cout << "ret" << ret <4. 如果函数的返回值是引用，那么这个函数调用可以作为左值
int& doWork3()
{
static int a =10;
return a;
}
void test()
{
doWork3() = 1000; //相当于写了 a=1000
}
5.引用的本质就是一个指针变量
//发现是引用，转换为 int* const ref = &a;
void testFunc(int& ref)
{
ref = 100; // ref是引用，转换为*ref = 100
}
int main()
{
int a = 10;
int& aRef = a; //自动转换为 int* const aRef = &a;这也能说明引用为什么必须初始化
aRef = 20; //内部发现aRef是引用，自动帮我们转换为: *aRef = 20;
cout << "a:" << a << endl;
cout << "aRef:" << aRef << endl;
testFunc(a);
return EXIT_SUCCESS;
}
6.指针的引用
- 二级指针开辟空间
#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
struct Person
{
int m_Age;
};
void allocatMemory(Person ** p) // **p 具体的Person对象 *p 对象的指针 p 指针的指针
{
*p = (Person *)malloc(sizeof(Person));
(*p)->m_Age = 100;
}
void test01()
{
Person * p = NULL;
allocatMemory(&p);
cout << "p的年龄： " <m_Age << endl;
}
- 用一级指针引用可以代替二级指针
//利用指针引用开辟空间
void allocatMemoryByRef(Person* &p) // Person* &p 指针的引用
{
p = (Person*)malloc(sizeof(Person));
p->m_Age = 1000;
}
void test02()
{
Person * p = NULL;
allocatMemoryByRef(p);
cout << "p的年龄：" << p->m_Age << endl;
}
7.常量引用
- const int& a = 10会分配内存
#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
void test01()
{
//int &ref = 10;//引用了不合法的内存，不可以
//加入const后 ，编译器处理方式为： int tmp = 10; const int &ref = tmp;
const int &ref = 10;
//ref = 10;
int * p = (int*)&ref;
*p = 1000;
cout << "ref = " << ref << endl;
}
- 使用场景 用来修饰形参为只读
void showValue(const int &val)
{
//val += 1000; //如果只是想显示内容，而不修改内容，那么就用const修饰这个形参
cout << "val = " << val << endl;
}
void test02()
{
int a = 10;
showValue(a);
}