C与C++的区别_const_引用

引用_const

1、 引用就是一个内存单元的别名 (底层以指针的方式来支持引用，在引用使用的地方，系统自带解引用过程)

引用一定要初始化

引用引用的变量一定要能取地址

引用不可改变的

只能访问引用变量所引用的内存块的内容

 

int &b = a;   b引用a，b指向a的内存块，即她俩地址相同

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int& b = a;
	cout << a << " " << &a << endl;
	cout << b << " " << &b << endl;
}

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int& b = a;
	cout << ++a << "  " << b << endl;//a的值改变b的值也随之改变
}

 

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);
	cout << "a: " << a << endl;
	cout << "b: " << b << endl;
}   //说明引用底层以指针方式处理

2、const &

引用引用的变量不能取地址  ==> 常引用可以处理

                      数值放到临时量(内存)    常引用引用临时量的内存单元

#include <iostream>
using namespace std;

int main()
{
	const int& a = 10;
	cout<<"a:  "<<a<<endl<<"&a: "<<&a<<endl;
}

3、const*  与  const**

const与**

#include <iostream>
using namespace std;


int main()
{
	
	int a = 10;
	int* p = &a;
	int**q = &p;

	const int a = 10;
	const int* p = &a; 
	const int**q = &p;
	/*
		const修饰：a
		const间接修饰：*p, **q,
	*/

	int a = 10;
	const int* p = &a;	 // const int*  <== int*
	const int**q = &p;  // int**  <== const int**
	/*
		const修饰：*p
		const直接修饰：a
		const间接修饰：*p **q

	*/

	int a = 10;
	int*const p = &a;  //  int* <== int*
	int*const*q = &p;      //   int** <==  int*const*
	/*
		const修饰：p
		const间接修饰：*q
	*/

	int a = 10;
	int* p = &a;
	const int**q = &p;  // const int**  <== int**
	/*
		const修饰：**q
		const直接修饰：a
		const间接修饰：**q , *(*q)  *q  p
	*/


	int a = 10;
	int* p = &a;
	int*const*q = &p;
	/*
		const修饰：*q
		const直接修饰：p
		const间接修饰：*q
	*/

	int a = 10;
	int* p = &a;
	int**const q = &p;
	/*
		const修饰：q
		const直接修饰：q
		const直接修饰：无
	*/
}

const与*

#include <iostream>
using namespace std;

int main()
{
    int a = 10;
	int*p = &a;
	int* q = p;

	const int a = 10;
	const int* p = &a;
	const int* q = p; 
	/*
		const修饰： *p
		const直接修饰：a 
		const间接修饰：*p *q
	*/

	int a = 10;
	const int*p = &a;//   const int* <== int*
	const int* q = p;		//    int* <== const int*
	/*
		const修饰：*p
		const直接修饰：a
		const间接修饰：*p *q
	*/


	int a = 10;
	int*const p = &a;  // int* const    <==  int*
	int* q = p;	// int*  <==  int* const
	/*
		const直接修饰：p
	*/

	int a = 10;
	int*p = &a;
	const int* q = p;  //  const int*  <==  int*
	/*
		const直接修饰：a
		const间接修饰：*q 
	*/

	int a = 10;
	int*p = &a;
	int*const q = p;  // int* <== int*
	/*
		const直接修饰：q

	*/
}

const修饰形参

1.防止形参被修改

2.接收临时变量

int Mul(const int& a, const int& b)
{
	return a * b;
}

int main()
{
	int a = 10;
	int b = 20;
	Mul(10, 20);
	return 0;
}

 

不能返回局部变量的指针和引用

若返回的是指针或者引用，函数带回的是变量的地址，而随着函数调用完毕会清空栈帧，若有下一个函数下一个函数会覆盖原来函数返回的地址。
 

C与C++的一些区别

动态申请数组

C++中使用     new    delete

C中使用      malloc   free

    void* malloc(size_t size);

    void  free(void *prt);

new与malloc区别：

    1. new是关键字

       malloc是一个函数

   2.  malloc在堆上生成

        new自主存取区域

   3.malloc只开辟内存

      new还可以初始化

   4.内存不足时

       malloc是返回NULL

       new会抛出异常

   5.malloc不能开辟常量内存

       new可以开辟常量内存

int main()
{
	int* p1 = (int*)malloc(sizeof(int)* 10);//0x100  40
	if (p1 == NULL)
	{
		cout << "error: no memory!" << endl;
	}
	free(p1);

	int* p2 = new int[10];
	delete[] p2;

	int* p3 = new int(10);
	cout << *p3 << endl;
	delete p3;

	int* p4 = new int[10]();
	delete[] p4;

	const int* p5 = new const int(10);
	delete p5;

	const int* p6 = new const int[10]();
	delete[] p6;

	int** p7 = (int**)malloc(sizeof(int*)* 10);
	for (int i = 0; i < 10; i++)
	{
		p7[i] = (int*)malloc(sizeof(int)* 10);
	}
	for (int i = 0; i < 10; i++)
	{
		free(p7[i]);
	}
	free(p7);

	int** p8 = new int*[10];
	for (int i = 0; i < 10; i++)
	{
		p8[i] = new int[10];
	}
	for (int i = 0; i < 10; i++)
	{
		delete[] p8[i];
	}
	delete[] p8;
}

C

全局作用域

局部作用域

C++

全局作用域

局部作用域

名字空间作用域

类作用域

namespace

           加上作用域

                  ::全局作用域访问符

                   名字空间名称::名字空间作用域访问符

                    类::类作用域访问符

using声明

             using  namespace  //using 指示符

           

int main()
{
    using CY1201::a;//using声明
    using namespace CY1201;//using指示符
}

 名字空间同名==>合并

namespace CY1201
{
    int a = 20;
    cout << a << endl;
}
namespace CY1201
{
    int a = 10;
}
//这段代码会报错a被重定义，所以可以判断出名字空间同名会合并