文章目录
一、数组
1.概述
所谓数组,就是一个集合,里面存放了相同类型的数据元素
特点1:数组中的每个数据元素都是相同的数据类型
特点2:数组是由连续的内存位置组成的
2.一维数组
2.1 一维数组定义的三种方法:
1.数据类型 数组名 [ 数组长度 ];
2.数据类型 数组名 [ 数组长度] = { 值1,值2,....};
3.数据类型 数组名 [ ] ={ 值1,值2,....};
2.2 一维数组数组名
用途:
1.可以统计整个数组在内存中的长度
2.可以获取数组在内存中的首地址
代码如下(示例):
int arr[5] = { 0 ,1 ,2 ,3 ,4 };
cout <<"整个数组占用的内存空间:" << sizeof(arr) <<endl; //20
cout <<"每个元素占用的内存空间:" << sizeof(arr[0]) << endl; //4
cout << "数组的元素个数:" << sizeof(arr) / sizeof(arr[0]) <<endl; //5
cout <<"数组首地址为:" << arr <<endl; //0x70fdf0
cout << "数组中第一个元素地址为:" << &arr[0] <<endl; //0x70fdf0
cout << "数组中第二个元素地址为:" << &arr[1] <<endl; //0x70fdf4
3.二维数组
3.1二维数组定义方式
有四种方式:
1.·数据类型 数组名 [ 行数 ] [ 列数 ];
2. 数据类型 数组名 [ 行数 ] [ 列数 ] = { {数据1,数据2},{ 数据3,数据4}} ;
3. 数据类型 数组名 [ 行数 ] [ 列数 ] = { 数据1,数据2, 数据3,数据4 } ;
4. 数据类型 数组名 [ ] [ 列数 ] = { 数据1,数据2, 数据3,数据4 } ;
第二种更加直观,提高代码可读性;
3.2 二维数组数组名
- 查看二维数组所占空间
- 获取二维数组首地址
二、函数
1.函数定义
函数的定义一般有5个步骤:
- 返回值类型
- 函数名
- 参数列表
- 函数体语句
- return xx
代码如下(示例):
返回值类型 函数名(int a, int b)
{
函数体语句;
return xx;
}
2.函数调用
功能:使用定义好的函数
语法:函数名(参数)
3.常见的样式
- 无参无返
- 有参无返
- 无参有返
- 有参有返
4.函数的分文件编写
作用:让代码结构更加清晰
函数分文件编写一般有4个步骤:
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明
4.在源文件中写函数的定义
//头文件swap.h
#include<iostream>
using namespace std;
//函数声明
void swap (int a,int b);
//swap.cpp
#include"swap.h"
//函数的定义
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout <<"a=" << a << endl;
cout <<"b=" << b << endl;
}
#include<iostream>
#include "swap.h"
using namespace std;
int main()
{
int a = 10;
int b = 20;
swap( a , b);
return 0;
}
5. C++类非静态成员函数后加const的作用
非静态成员函数后面加const,表示成员函数隐含传入的this指针为const指针,在该成员函数中,不能修改所在类中的成员变量
但可以修改有mutable
修饰的成员
加到
非成员函数或静态成员
后面会产生编译错误
三、指针
1.指针的定义和使用
指针变量定义语法:数据类型 * 变量名 ;
代码如下(示例):
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//定义指针
int* p;
//给指针赋值
p = &a;
cout << p << endl; //打印数据a的地址(十六进制)
cout << *p << endl; //打印数据a的值
//可以这样定义
int *p = &a; //等同于 int *p; p = &a;
return 0;
}
2.指针所占的内存空间
不管是什么数据类型
32位操作系统下:占用4个字节空间。
64位操作系统下:占用8个字节空间。
int a = 10;
//定义指针
int* p;
//给指针赋值
p = &a;
cout << "sizeof(int *):" << sizeof(p) << endl; //4
3.空指针和野指针
空指针:指针变量指向内存中编号为0的空间
用途:初始化指针变量
注意:空指针指向的内存是不可以访问的
//空指针
int* p = NULL;
//空指针不能访问,但可以初始化指针变量
//0~255之间的内存编号是系统占用,因此不可以访问
野指针:指针变量指向非法的内存空间
//指针变量指向内存地址编号为0x1100的空间
int* p = (int*)0x1100;
//访问野指针会报错
cout << *p << endl; //: 读取访问权限冲突。
总结:空指针和野指针都不是我们申请的空间,因此不能访问。
4.const修饰指针
有三种情况:
- const修饰指针 —常量指针
- const修饰常量 —指针常量
- const既修饰指针,又修饰常量
int a = 10;
int b = 20;
//1.const修饰指针
//指针指向的值不可以改,指针的指向可以改
const int* p1 = &a;
//则*p1 = 20;是一个错误
cout << p1 << endl; //输出的是地址
cout << *p1 << endl; //输出的是10
//2.const修饰常量
//指针指向的值可以改,指针的指向不可以改
int* const p2 = &b;
*p2 = 100;//正确
p2 = &a; //错误
//3.const既修饰指针又修饰常量
const int* const p3 = &a;
//指针的指向和指向值都不可以改
5.指针和数组
作用:利用指针访问数组元素
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "数组的第一个元素:" << arr[0] << endl;
int* p = arr; //arr就是数组的首地址
cout << "利用指针访问第一个元素:" << *p << endl;
cout << "利用指针访问第二个元素:" << *(p + 1) << endl;
// 访问二维数组
int a[][] = {{1,2,3}, {4,5,6}, {7,8,9} };
a[0][0] = **a;
a[0][1] = *(*a + 1);
a[0][2] = *(*a + 2);
a[1][0] = **(a+1);
a[1][1] = *(*(a+1)+1);
a[1][2] = *(*(a+1)+2);
a[2][0] = **(a+2);
a[2][1] = *(*(a+2)+1);
a[2][2] = *(*(a+2)+2);
6.指针和函数
作用:利用指针做函数参数,可以修改实参的值
#include<iostream>
using namespace std;
//值传递
void swap1(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
//地址传递
void swap2(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main()
{
int a = 10;
int b = 20;
swap1(a, b); //值传递不会改变实参
cout << a << endl; //10
cout << b << endl; //20
swap2(&a, &b); //地址传递会改变实参
cout << a << endl; //20
cout << b << endl; //10
return 0;
}
总结:如果不想改变实参,就用值传递,如果想改变实参,就用地址传递