|
new 的返回值是 指针类型；
#include <iostream>
using namespace std;
int* func()
{
//利用new在堆区开辟一块空间
//new返回值是一个指针
int * p = new int(10);
return p;
}
void test01()
{
int* p = func();
cout << *p << endl;
//堆区的数据由程序员管理
//delete释放内存
delete p;
}
void test02()
{
//利用new在堆中创建一个数组
int *arr = new int[10];
for (int i = 0; i < 10; i++)
{
arr[i] = 100 + i;
}
for (int i = 0; i < 10; i++)
{
cout << arr[i] << endl;
}
//释放一个数组
delete [] arr;
}
int main()
{
test01();
test02();
return 0;
}
引用
本质是给变量起别名（不能直接给其赋常量值）
引用必须要初始化（声明时必须给原名）
一旦初始化不能更改其原名（计算机会认为是在赋值）
#include <iostream>
using namespace std;
int main()
{
//引用的基本语法
//数据类型 &别名 = 原名
int A = 10;
int& B = A;
int c = 20;
cout << "A=" << A << endl;//10
cout << "B=" << B << endl;//10
B = 100;
cout << "A=" << A << endl;//100
cout << "B=" << B << endl;//100
B = c;
cout << "A=" << A << endl;//20
cout << "B=" << B << endl;//20
B = 100;
cout << "A=" << A << endl;//100
cout << "B=" << B << endl;//100
cout << "c=" << c << endl;//20
}
引用做参数
利用引用让形参修饰实参
#include <iostream>
using namespace std;
//利用指针
void MySwap01(int *a,int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
//利用引用
void MySwap02(int &a , int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int a = 10;
int b = 20;
MySwap01(&a, &b);
cout << "a=" << a<< endl;
cout << "b=" << b << endl;
MySwap02(a, b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
return 0;
}
利用引用作函数的返回值
不要返回局部变量的引用（局部变量的生命周期是其函数体内 可以用static来修饰其变量从而达到扩展作用域延长生命周期 一般情况下即使返回了局部变量 马上使用也会有一次的值是对的是因为计算机帮保留了这个数）
函数调用可以作为左值（返回值是引用其实就是返回其原名变量的别名 给函数赋值就是给其别名赋值从而改变其原名变量）
#include <iostream>
using namespace std;
int& test()
{
static int a = 10;//静态变量和全局变量都都存放在全局区，全局区的数据在程序结束后系统才会释放
return a;
}
int main()
{
int& ref = test();
cout << "ref="<< ref << endl;
test() = 1000;
cout << "ref=" << ref << endl;
return 0;
}
#include <iostream>
using namespace std;
int& test()
{
static int a = 10;//静态变量和全局变量都都存放在全局区，全局区的数据在程序结束后系统才会释放
cout << "test_a=" << a << endl;
return a;
}
int main()
{
int& ref = test();
cout << "ref="<< ref << endl;
test() = 1000;
cout << "ref=" << ref << endl;
test();
return 0;
}
//test_a = 10
//ref = 10
//test_a = 10
//ref = 1000
//test_a = 1000
引用的本质就是指针常量，对于指针常量来说指向的对象是不能改变的，值是可以改变的
int * const ref = &a;
const 修饰所以不能改变指针的指向? 但是可以改变a内存里面的值；
常量引用
主要用于修饰形参，防止形参修饰实参
用const 修饰引用也可以直接给这个引用赋个常量
#include <iostream>
using namespace std;
void ShowValue(const int &a)
{
cout << "a=" << a << endl;
}
int main()
{
int a = 10;
const int & ref = 10;
ShowValue(a);
return 0;
}
函数?
函数的默认参数（在c++中函数的形参列表中的形参是可以有默认值的）
语法： 返回值类型 函数名 （参数 = 默认值）{}
默认值必须保证左边第一个出现的地方到右边左后一个都要有默认值。
如果函数的声明有默认参数，函数实现就不能有默认值
#include <iostream>
using namespace std;
int fun(int a, int b = 20, int c = 30);
int fun(int a,int b, int c)
{
return a + b + c;
}
int main()
{
cout << fun(10,30) << endl;//70
return 0;
}
函数的占位参数
c++中函数的形参列表有占位参数，用来占位，调用函数时必须填补该位置
语法：返回值类型 函数名 （类型）{}
占位参数可以有默认值
#include <iostream>
using namespace std;
void fun(int a,int = 10)
{
cout << "this is fun" << endl;
}
int main()
{
fun(10);
return 0;
}
函数的重载
同一作用域下 函数名相同 参数类型/个数/顺序不同
#include <iostream>
using namespace std;
void fun()
{
cout << "fun()" << endl;
}
void fun(int a)
{
cout << "fun(int a)" << endl;
}
void fun(double a)
{
cout << "fun(double a)" << endl;
}
void fun(int a ,double b)
{
cout << "fun(int a ,double b)" << endl;
}
void fun(double b, int a)
{
cout << "fun(double b, int a)" << endl;
}
int main()
{
fun();
fun(10);
fun(3.14);
fun(10, 3.14);
fun(3.14, 106);
return 0;
}
引用作为重载条件和const修饰的重载
#include <iostream>
using namespace std;
void func(int &a)
{
cout << "func(int &a)" << endl;
}
void func(const int &a)
{
cout << "func(const int &a)" << endl;
}
int main() {
int a = 10;
func(a);//func(int &a)
func(10);//func(const int &a)
const int b = 20;
func(b);//func(const int &a)
return 0;
//如果没有func(int &a)他们三个都会调用func(const int &a)
//如果没有func(const int &a)后面两个不能正常调用
}
函数重载碰到默认参数
#include <iostream>
using namespace std;
void func(int a)
{
cout << "func(int a)" << endl;
}
void func(int a,int b = 10)
{
cout << "func(int a,int b = 10)" << endl;
}
int main()
{
func(10,20);//用不了func(int a)
return 0;
}
|