C++笔记 01 （C++入门）

Panrison

已于 2022-07-03 17:32:02 修改

阅读量216

点赞数 1

分类专栏： C++笔记文章标签： c++ 开发语言

于 2022-06-20 22:43:59 首次发布

本文链接：https://blog.csdn.net/pangyushuang/article/details/125375821

版权

C++笔记专栏收录该内容

23 篇文章 0 订阅

订阅专栏

本文详细介绍了C++的基础知识，包括程序流程控制如三目运算符、循环与跳转语句，数组的一维和二维使用，函数的作用、值传递与地址传递，以及指针的基本概念和操作。此外，还讲解了结构体的定义、使用及结构体数组、结构体指针的相关内容。

摘要由CSDN通过智能技术生成

一. 程序流程结构

在C++中三目运算符返回的是变量，可以继续赋值。

例1：

int a=10;
int b=20;
int c=0;
(a>b?a:b)=100;
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;

输出为：

a=10;
b=100;

随机数生成

例2：

#include<ctime>

srand ((unsigned int))tine(NULL); /*随机数种子，利用当前系统时间
生成随机数，防止每次随机值都一样*/

int num=rand()%100; //生成0-99随机数
//int num=rand()%100+1; //生成1-100随机数

嵌套循环
外层执行一次，内层执行一周
break 语句
1）出现在switch条件语句中，作用是终止case并跳出switch；
2）出现在循环语句中，作用是跳出当前循环语句；
3） 出现在嵌套循环中，跳出最近的内层循环语句；
continue 语句
在循环语句中，跳过本次循环余下尚未执行的语句，继续执行下一次循环；continue不会使整个循环终止，而break会跳出循环。
goto语句
作用：可以无条件跳转语句（但不建议使用）
语法：goto 标记；
解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置

二. 数组

一维数组名称的用途
1）可以统计整个数组在内存中的长度
2）可以获取数组在内存中的首地址

int arr[10]={1,2,3,4,5,6,7,8,9,10}

cout<<sizeof(arr)<<endl; //数组长度
cout<<arr<<endl; //首地址

//注意，数组名是常量，因此不可以赋值；  例如 arr=100; (错误)

二维数组
外层循环打印行数，内层循环打印列数

推荐使用：数组类型数组名【行数】【列数】={ {数据1，数据2}，{数据3，数据4} }；

三. 函数

作用：将一段经常使用的代码封装起来，减少重复代码。
一个较大的程序，一般分为若干程序块，每个模块实现特定的功能。

语法:

返回值类型 函数名 （参数列表）
                 { 
                 函数体语句;
                 return 表达式 ;
                  }`

值传递
所谓值传递，就是函数调用时实参将数值传给形参；值传递时，如果形参发生改变，并不会影响实参。
函数写在主函数之后时，要进行函数声明；
函数写在主函数之前时，不需要进行函数声明。
（声明可以写多次，但定义只能有一次）
函数的分文件编写
作用：让代码结构更加清晰
步骤：1）创建后缀名为.h的头文件；
2）创建后缀名为.cpp的源文件；
3）在头文件中写函数的声明；
4）在源文件中写函数的定义
（在主函数源文件中添加 #include “xxx.h”)

四. 指针

指针变量定义语法：
数据类型 * 指针变量名
在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型；
在64位操作系统下，指针是占8个字节空间大小，不管是什么数据类型；
空指针（指向内存中编号为0的空间）
1）空指针用于给指针变量进行初始化 int *p=NULL；
2）空指针是不可以进行访问的（0-255之间的内存编号是系统占用的，因此不可以访问）
野指针（指针变量指向非法的内存空间）

int* p= (int*) 0x1100;  //指针变量p指向内存地址为编号为0x1100的空间

cout<<*p<<endl; //访问野指针报错

（空指针和野指针都不是我们申请的空间，因此不要访问）

const 修饰指针（3种情况）
1）const 修饰指针—— 称为 “常量指针”；
2) const 修饰常量—— 称为“指针常量”；
3）const 既修饰指针，又修饰常量；

若 
int a=10;
   int b=10;
   int*p=&a;
   
1)常量指针（指针指向的值不可以改）
  const int *p= &a;
 特点：指针的指向可以修改，但是指针指向的值不可以修改
 *p =20;(错误)
  p=&b; (正确）
  
2)指针常量（指针的指向不可以修改）
 int *const p=&a;
 特点：指针的指向不可以改，指针指向的值可以改
 *p=20(正确)
 p=&b;(错误）
 
3）既修饰指针，又修饰常量
const int *const p=&a;
特点：指向和值均不可以改
*p =20(错误）
p=&b; (错误）

利用指针访问数组中的元素

int arr[]={1,2,3};
int *p=arr; //arr就是数组的首地址
for (int i=0;i<3;i++)
{
cout<<*p<<endl;
p++; //利用指针遍历数组
}

地址传递

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); //值传递不会改变实参
swap2(&a,&b); //地址传递会改变实参
}

五. 结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
语法：struct 结构体名 {结构体成员列表}；

通过结构体创建变量的方式有3种

//结构体定义

struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
}；stu3; //方式3

int main()
{
//方式1
struct student stu1; //struct 关键字可以省略
stu1.name="张三";
stu1.age=18;
stu1.score=100;
cout<<"姓名："<<stu1.name<<"年龄："<<stu1.age<<"分数："<<stu1.score<<endl;

//方式2
struct student stu2={"李四",19,60};
cout<<"姓名："<<stu2.name<<"年龄："<<stu2.age<<"分数："<<stu2.score<<endl;

//方式3  （在定义结构体时创建结构体变量，但不推荐）
stu3.name="王五";
stu3.age=18;
stu3.score=80;
}

结构体数组

 1）定义结构体
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
}；

 2）创建结构体数组
struct student stuArray[3]=
{
{"张三",18,100},
{"李四",28,99},
{"王五",38,66}
};

3)给结构体数组中的元素赋值
stuArray[2].name="赵六";
stuArray[2].age =80;

4)遍历结构体数组
for(int i=0;i<3:i++)
{
cout<<"姓名："<<stuArray[i].name<<"年龄："<<stuArray[i].age<<"分数："<<stuArray[i].score<<endl;
}

结构体指针

 1）定义结构体
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
}；

2）创建学生结构体变量
struct student s ={"张三"，18，100}；

3）通过指针指向结构体变量
struct student *p=&s;

4)通过指针访问结构体变量中的数据
cout<<"姓名："<<p->name<<"年龄："<<p->age<<"分数："<<p->score<<endl;
}

结构体嵌套结构体

//学生结构体定义
struct student
{
string name;
int age;
int score;
};

//教师结构体定义
struct teacher
{
int id;
string name;
int age;
struct student stu;//子结构体，学生
}；

int main()
{
struct teacher t1;
t1.id=100;
t1.name="老王";
t1.stu.name="张三";
t1.stu.age=18;
}