https://www.processon.com/mindmap/61d843bfe401fd06a8bc891c
只有单一变量
前提知识点数组
复合类型数据
1-1数组定义大小时候不能是变量
1-2 数组初始化
1-3字符串
字符串数组的长度
显式的定义
隐式的定义
样例1 函数数组作为输入
CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(test)
set(Current_LIST main.cpp )#Current_LIST记录要参与可执行文件的源代码
add_executable(${PROJECT_NAME} ${Current_LIST} )#可执行文件
main.cpp
#include <iostream>
using namespace std;
const int Arsize=8;//用来定义数组大小 数组大小是定义好的，不能随便因为变量改变，因此数值必须是固定的 const
int sum_arr(int arr[],int n);
int main(){
int arr_test[Arsize]={1,2,3,4,5,6,7};
int sum=sum_arr(arr_test,Arsize);
cout<<"数组和："<<sum <<endl;
return 0;
}
int sum_arr(int arr[],int n)
{
int total=0;
for(int i=0;i<n;i++)
{
total=total+arr[i];
}
return total;
}
编译
cd build cmake .. make ./test
样例2 函数使用指针来处理数组作为输入
// 将数组名解释为其第一个元素的地址
数组名字被视为首个元素的地址
定义函数
使用数据
数组coolies名字本身就被当成地址使用，所以不需要加 &
等效的
样例3 函数使用指针来处理结构体作为输入
结构体名字类似于单数据名字，函数作为拷贝副本传入处理
但是如果结构体偏大，为避免拷贝，使用&传递结构体地址，直接操作结构体本身数据。
使用加入&
引用变量
引用变量
引用函数
样例1 单一变量的函数输入，引用，指针
CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(test)
set(Current_LIST main.cpp )#Current_LIST记录要参与可执行文件的源代码
add_executable(${PROJECT_NAME} ${Current_LIST} )#可执行文件
main.cpp
#include <iostream>
using namespace std;
void swap_kaobei(int a,int b);
void swap_zhizhen(int *a,int *b);
void swap_yinyong(int &a,int &b);
int main(){
//------------------测试1 变量测试 引用 指针 拷贝-----------------------
int a=10;
int b1=a;
a=11;
cout<<"变量B1指向的数据 " <<"a" << "指针B1指向的数据内容"<< b1 <<endl;
a=10;
int *b2=&a;
a=12;
cout<<"指针B2指向的数据位置" <<b2 << "指针B2指向的数据内容"<< *b2 <<endl;
a=10;
int &b3=a;
a=13;
cout<<"引用B3重复名代表 " <<"a" << "引用B3重复名代表数据内容"<< b3 <<endl;
//------------------测试2 函数输入测试 引用 指针 拷贝-----------------------
int a1=1;
b1=2;
swap_kaobei(a1,b1);
cout<<"输入前 a-" << a1 << " b-"<< b1 <<endl;
cout<<"变量拷贝函数处理后 a-" << a1 << " b-"<< b1 <<endl;
cout<<"变量拷贝函数处理的是拷贝数值"<<endl;
a1=1;
b1=2;
swap_zhizhen(&a1,&b1); //输入类型指针 *a *b 所以要给一个地址而非变量
cout<<"输入前 a-" << a1 << " b-"<< b1 <<endl;
cout<<"指针函数处理后 a-" << a1 << " b-"<< b1 <<endl;
cout<<"指针函数处理的是原数值"<<endl;
a1=1;
b1=2;
swap_yinyong(a1,b1);//输入类型 引用&
cout<<"输入前 a-" << a1 << " b-"<< b1 <<endl;
cout<<"引用函数处理后 a-" << a1 << " b-"<< b1 <<endl;
cout<<"引用函数处理的是原数值"<<endl;
return 0;
}
//变量拷贝输入测试
void swap_kaobei(int a,int b)
{
int temp=a;
a=b;
b=temp;
}
//指针输入测试
void swap_zhizhen(int *a,int *b)
{
int temp=*a;
*a=*b;
*b=temp;
}
//引用变量输入测试
void swap_yinyong(int &a,int &b)
{
int temp=a;
a=b;
b=temp;
}
编译执行
cd build cmake .. make ./test
结果
样例2 单一变量，结构体，类作为参数输入函数
mian.cpp
#include <iostream>
using namespace std;
//1 数组测试-唯一 传入原值
const int Arsize=8;//用来定义数组大小 数组大小是定义好的，不能随便因为变量改变，因此数值必须是固定的 const
int sum_arr(int arr[],int n);
//2 结构体 -皆可 小数据传拷贝 大数据传原值
struct Stct_Test1
{
int a;
int b[3];
};
//3 类 传输原值
class class_Test1
{
public:
int a;
int b[3];
};
int function_single(int a,int &b);
int function_sum_Arr(int arr[],int n);
void function_struct_kaobei(Stct_Test1 stct_test);
void function_struct_zhizhen(Stct_Test1 *stct_test);
void function_struct_yinyong(Stct_Test1 &stct_test);
void function_class_kaobei(class_Test1 class_test);
void function_class_zhenzhen(class_Test1 *class_test);
void function_class_yinyong(class_Test1 &class_test);
int main(){
//0 单一变量测试
int a=1;
int b=2;
cout<<"修前 a-"<<a << " b-" << b <<endl;
function_single(a,b);
cout<<"a拷贝副本函数修改后 a-"<<a << " b引用&原值修改后结果" << b <<endl;
//1数组函数输入测试
int arr_test[Arsize]={1,2,3,4,5,6,7};
//sum_arr输入类型指针 （地址） 数组名本来就是当做数组首地址地址处理 所以arr_test不需要像单一变量一样加&取地址符号来获取地址
// arr_test == &arr_test[0]
int sum=function_sum_Arr(arr_test,Arsize);
cout<<"数组数据使用求和："<<sum <<endl;
cout<<"数组数据arr_test[0]= 修改前 1 ,修改后 "<<arr_test[0] <<endl;
//2结构体测试
Stct_Test1 struct_test1={1,{1,2,3}};
function_struct_kaobei(struct_test1);
cout<<"拷贝修改后 struct_test1.a-"<<struct_test1.a<<" struct_test1.b-" <<struct_test1.b[0]<<endl;
struct_test1={1,{1,2,3}};
function_struct_zhizhen(&struct_test1);
cout<<"指针修改后 struct_test1.a-"<<struct_test1.a<<" struct_test1.b-" <<struct_test1.b[0]<<endl;
struct_test1={1,{1,2,3}};
function_struct_yinyong(struct_test1);
cout<<"引用修改后 struct_test1.a-"<<struct_test1.a<<" struct_test1.b-" <<struct_test1.b[0]<<endl;
//3类对象使用
class_Test1 class_test1;
class_test1.a=1;
class_test1.b[0]=1;
class_test1.b[1]=1;
class_test1.b[2]=1;
function_class_kaobei(class_test1);
cout<<"拷贝 类修改后 class_test1.a-"<<class_test1.a<<" class_test1.b-" <<class_test1.b[0]<<endl;
class_test1.a=1;
class_test1.b[0]=1;
class_test1.b[1]=1;
class_test1.b[2]=1;
function_class_zhenzhen(&class_test1);
cout<<"指针 类修改后 class_test1.a-"<<class_test1.a<<" class_test1.b-" <<class_test1.b[0]<<endl;
class_test1.a=1;
class_test1.b[0]=1;
class_test1.b[1]=1;
class_test1.b[2]=1;
function_class_yinyong(class_test1);
cout<<"引用 类修改后 class_test1.a-"<<class_test1.a<<" class_test1.b-" <<class_test1.b[0]<<endl;
//16.4.1
return 0;
}
//1----------单一变量测试 a 拷贝副本 b 引用原值
// 调用 single(a,b)
int function_single(int a,int &b)
{
a=10;
b=11;
}
//2---------数组测试-------
// 0将数组名解释为其第一个元素的地址
// 1普通变量解释为普通变量的拷贝值
// 调用 sum_arr(arr,n)
int function_sum_Arr(int arr[],int n)
//int sum_arr(int *arr,int n) //等价
{
int total=0;
for(int i=0;i<n;i++)
{
total=total+arr[i];
}
arr[0]=total;//修改数组内容
return total;
}
//3-1--------------结构体函数输入 拷贝副本
// 调用 sum_arryinyong(stct_test)
void function_struct_kaobei(Stct_Test1 stct_test)
{
stct_test.a=10;
stct_test.b[0]=10;
stct_test.b[1]=11;
stct_test.b[2]=12;
}
//3-2--------------结构体函数输入 指针使用原值
// 调用 sum_arryinyong(&stct_test)
void function_struct_zhizhen(Stct_Test1 *stct_test)
{
stct_test->a=10;
stct_test->b[0]=10;
stct_test->b[1]=11;
stct_test->b[2]=12;
}
//3-2--------------结构体函数输入 引用使用原值
// 调用 function_struct_yinyong(stct_test)
void function_struct_yinyong(Stct_Test1 &stct_test)
{
stct_test.a=20;
stct_test.b[0]=20;
stct_test.b[1]=21;
stct_test.b[2]=22;
}
//4-1--------------类对象函数输入 拷贝副本
// 调用 sum_arryinyong(stct_test)
void function_class_kaobei(class_Test1 class_test)
{
class_test.a=10;
class_test.b[0]=10;
class_test.b[1]=11;
class_test.b[2]=12;
}
//4-2--------------类对象函数输入 指针原数据
// 调用 sum_arryinyong(&stct_test)
void function_class_zhenzhen(class_Test1 *class_test)
{
class_test->a=10;
class_test->b[0]=10;
class_test->b[1]=11;
class_test->b[2]=12;
}
//4-3--------------类对象函数输入 引用原数据
// 调用 function_class_kaobei(stct_test)
void function_class_yinyong(class_Test1 &class_test)
{
class_test.a=20;
class_test.b[0]=20;
class_test.b[1]=21;
class_test.b[2]=22;
}
样例3 结构体访问和创建指针
#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
struct Struct_Car
{
char name[10];
int num;
float vloe;
};
int main(){
//4.8.4节
// 1-1静态创建 正常创建
Struct_Car car_test1;
strcpy(car_test1.name,"jack");
car_test1.num=1;
car_test1.vloe=10.0;
cout<<"静态创建，正常模式访问" <<car_test1.name << car_test1.num<< car_test1.vloe <<" 大小 "<< sizeof(car_test1) <<endl;
//1-2创建一个指针 指向结构体
Struct_Car *car_test1_pr=&car_test1;
cout<<"静态创建，指针模式访问" <<(*car_test1_pr).name << car_test1_pr->num<< car_test1_pr->vloe <<" 大小 "<< sizeof(*car_test1_pr) <<endl;
cout<<sizeof(int) << " "<<sizeof(float)<<endl;
// 2-1静态创建 指针引用-报错不能用，只是创了个指针，并没有分配空间
Struct_Car *car_test2;
strcpy( (*car_test2).name,"jack");
car_test2->num=2;
car_test2->vloe=3.0;
cout<<"静态创建，指针模式访问" <<car_test2->name << car_test2->num<< car_test2->vloe <<" 大小 "<< sizeof(*car_test2) <<endl;
//2-2 正确的使用指针创建模式 new Struct_Car分配了空间
Struct_Car *car_test3 =new Struct_Car;
strcpy( (*car_test3).name,"jack111");
car_test3->num=2;
car_test3->vloe=3.0;
cout<<"动态创建，指针模式访问" <<car_test3->name << car_test3->num<< car_test3->vloe<<" 大小 "<< sizeof(*car_test3) <<endl;
return 0;
}
浙公网安备 33010602011771号