函数

带默认值的函数

有一个函数有两个形参A和B，它的功能是分别输出这A和B的数值

void output(int A,int B)
{
	printf(A = %d\n B = %d);
}

在C语言中，必须输入给两个形参传参，而在C++里可以实现只传入一个参数

//带默认值的函数，声明和定义只有一方写默认值
//声明一个带默认值的函数
void output(int A = 100,int B = 200);

int main()
{
	int data = 10;
	output(data);//只传入了一个参数
}

void output(int A,int B)
{
	printf("A = %d\n B = %d",A,B);
}

输出结果

A = 10
B = 200

函数的重载

函数重载是指:
在同一个作用域内，可以有一组具有: 相同函数名、不同形参列表的函数

重载的底层原理实际是:
编译器会将重载函数设置成不用的函数名，根据参数类型与个数进行匹配

语法
函数名必须相同
形参列表必须不同（个数不同、类型不同、参数排列顺序不同）
注：单纯的函数返回值不同是无法构成重载的

下面是正确语法的

下面是错误语法的

C++引用

学习C++引用之前，先回顾一下C语言的const修饰指针操作

在这里插入图片描述

//伪代码
int A = 10;
int B = 20;
	P = &A;

常量指针:修改P存放的地址为&B 不允许，通过P修改A的数值为100 允许
指针常量:修改P存放的地址为&B 允许，通过P修改A的数值为100 不允许
常量指针常量:修改P存放的地址为&B 不允许，通过*P修改A的数值为100 不允许

引用的本质实际就是C语言的:指针常量 int * const P

语法：
<数据类型> & <变量名> = <目标变量/对象名> int & P = A;

int main()
{
	int A = 10;
	int &P = A; //int * const P = &A;//指针常量（可以修改值，不能改地址）
	P = 100;
	printf("P = %d A = %d\n",P,A);
}

输出结果

P = 100
A = 100

new 与 delete

先回顾一下C语言的malloc()、free();创建与释放函数

创建与销毁一个int类型变量
int *A = (int *) malloc(sizof(int));
*A = 100;
free(A);

创建销毁一个int类型数组
int *B = (int *) malloc(sizof(int)*3);
B[0] = 100,B[1] = 200,B[2] = 300;
free(B);

在C++中new 与 delete的关系 就好比 C语言中的malloc 与 free 的关系

new :
申请内存并初始化对象

delete：
释放内存并销毁对象

创建与销毁一个int类型变量
int * A = new int(100);
delete A;

创建销毁一个int类型数组
int * B = new int[3];
B[0] = 100,B[1] = 200,B[2] = 300;
delete []B;

命名空间

C++关键字 ：namespace
定义： namespace 命名空间名 { 代码 }

#include<stdio.h>

//专属作用域 命名空间
//相当于开辟了一块独立空间
namespace my_variate_1
{
    int a = 100;
    char b[] = "my_variate_1";

    void show(void)
    {
        printf("hello!\n");
    }
}

//专属作用域 命名空间
//相当于开辟了一块独立空间
namespace my_variate_2
{
    int a = 200;
}

using namespace my_variate_2 ;	//全局引用命名空间 my_variate_2
using my_variate_1 :: b;		//只引用my_variate_1 中的 b

int main()
{
    printf("%d\n",a);//这里的a及为全局引用a
    printf("%s\n",b);
    printf("%d\n",my_variate_1::a);
    return 0;
}

输出结果

200
my_variate_1
100

c++c语言 c语言学习学习学习

C++学习笔记 基础简介