c++基础学习第三天（指针，结构体，运算符）

liulangzhehwm

已于 2024-06-15 17:10:56 修改

阅读量1k

点赞数 22

分类专栏： c++的基础知识和进阶文章标签： c++ 学习

于 2024-03-04 19:07:38 首次发布

本文链接：https://blog.csdn.net/xiaiming0/article/details/136459077

版权

c++的基础知识和进阶专栏收录该内容

12 篇文章 0 订阅

订阅专栏

c++基础学习第三天（指针，结构体，运算符）

1、指针

1.1、指针的基本概念

指针的作用：可以通过指针间接访问内存(存储数据地址)

内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址

1.2、指针变量的定义和使用

指针变量定义语法：数据类型 *变量名；

//1、定义指针
int a1 = 10;
// 指针定义的语法：数据类型 * 指针变量名：
int *p;
// 让指针记录变量a的地址
p = &a1;
cout << "a的地址为：" << &a1 << endl;
cout << "指针p为：" << p << endl;
//2、使用指针
//可以通过解引用的方式来找到指针指向的内存,查看内存内容。
//指针前加 * 代表解引用，找到指针指向的内存中的数据
*p = 1000;
cout << "a1 = " << a1 << endl;
cout << "*p=" << *p << endl;

1.3、指针所占内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

在32位操作系统下：占用4个字节空间，64位下占8个字节。不管是什么数据类型（是地址只和操作系统有关）

//指针所占内存空间
int a2 = 10;
//int p;
//p=&a:
int *p1 = &a2;
//在32位操作系统下，指针是占4个字节空间大小，***不管是什么数据类型***
//在64位操作系统下，指针是占8个字节空间大小
cout << "sizeof(int*)=" << sizeof(int*) << endl;
cout << "sizeof (float*)=" << sizeof(float*) << endl;
cout << "sizeof (double*)=" << sizeof(double*) << endl;
cout << "sizeof(char*)="<< sizeof(char*) << endl;

1.4、空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的

空指针

//1、空指针用于给指针变量进行初始化
int *p4 =  NULL;
// 2、空指针(0号内存空间)是不可以进行访问的
//0~255之间的内存编号是系统占用的，因此不可以访问
//*p = 100;

野指针：指针变量指向非法的内存空间(不是自己申请的内存空间)

/野指针
//在程序中，尽量避免出现野指针
int *p = (int*)0x1100;
cout << * p << endl;

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

1.5、 const修饰指针

const修饰指针有三种情况：

1.5.1、const修饰指针-常量指针

const int *p=&a:

特点：指针的指向可以修改，但是指针指向的值不可以改

*p=20;//错误，指针指向的值不可以改
p=&b;//正确，指针指向可以改

1.5.2、const修饰常量-指针常量

int * const p=&a:

指针常量
特点：指针的指向不可以改，指针指向的值可以改

*p=20;//正确，指向的值可以改
p=&b;//错误，指针指句不可以改

1.5.3、const即修饰指针，又修饰常量

const int * const p =a;

特点：指针的指向和指针指向的值都不可以改

*p=20;//错误
p=&b;//错误

//1、const修饰指针   常量(const)指针(*)
int a4 = 10;
int b4 = 10;
const int * p7 = &a4;
//指针指向的值(*P)不可以改，指针的指向(p)可以改
//*p=20:错误
p7 = &b4;//正确

//2、const修饰常量 指针(*)常量(const)
//指针的指向(p2)不可以改，指针指向的值(*p2)可以改
int * const p5 = &a4;
*p5 = 100; // 正确的
//p2=&b:/错误，指针的指向不可以改

// 3、const修饰指针和常量
const int * const p6 = &a4;
//指针的指向和指针指向的值都不可以改
//*p3=100;//错误
//b3 = &b; //错误

1.6、指针和数组

作用：利用指针访问数组中元素

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "第一个元素为：" << arr[0] << endl;
int * p = arr;//arr就是数组首地址
cout << "利用指针访问第一个元素：" << *p << endl;
p++; // 让指针向后偏移4个字节，int *p中的int只是修饰p，表示地址里数据的大小，
     //不代表p的大小，p的大小只和操作系统有关
cout << "利用指针访问第三个元素：" << *p << endl;

cout << "利用指针遍历数组" << endl;
int *p2 = arr;
for (int i = 0; i < 10; i++)
{
	//cout <arr[i]<end1;
	cout<< *p2<< endl;
	p2++;
}

1.7、指针和函数

作用：利用指针作函数参数，可以修改实参的值

//值传递
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); //地址传递会改变实参

	cout << "a = " << a << endl;

	cout << "b = " << b << endl;

	system("pause");

	return 0;
}

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

2、结构体

2.1、结构体基本概念

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

2.2、结构体定义和使用

语法：struct 结构体名 {结构体成员列表};
通过结构体创建变最的方式有三种：

struct 结构体名变量名
struct 结构体名变量名={成员1值，成员2值…}
定义结构体时便创建变星

通过学生类型创建具体学生

//1 struct Student sl
struct Student s1;
//给s1属性赋值，通过.访问结构体变量中的属性
s1.name = "张三";
s1.age = 18;
s1.score = 100;
cout << "姓名：" << s1.name << "  年龄：" << s1.age << "  分数：" << s1.score << endl;

//2 struct Student s2 ={..};
struct Student s2 = { "李四",19,80 };
cout << "姓名：" << s2.name << "  年龄：" << s2.age << "  分数：" << s2.score << endl;

//3在定义结构体时顺便创建结构体变量
struct Student1 {
	//成员列表
	// 姓名
	string name;
	// 年龄
	int age;
	//分数
		int score;
}s3;

s3.name = "王五";
s3.age = 20;
s3.score = 60;
cout << "姓名：" << s3.name << "  年龄：" << s3.age << "  分数：" << s3.score << endl;

struct关键字可以省略(创建变量时)，定义时struct关键字不可以省略。
总结1：定义结构体时的关键字是struct,不可省略
总结2：创建结构体变是时，关键字structi可以省略
总结3：结构体变量利用操作符 " . " 访门成员

运算符

在C++中 “＆”，“*”，“.”、“->”、":“和”::"都是运算符

& 取地址符、引用符、按位与运算符。

取地址运算符：&用于获取变量的内存地址
引用类型：&可以用于定义引用类型，即某个变量的别名。
位运算中的按位与：&可以用于执行按位与操作，对两个数的二进制位进行逐位的与操作。
可用作函数参数的引用传递：C++中的引用传递也称为按引用传递或引用参数。这种方式允许函数通过引用来操作原始变量，而不是通过复制变量的值。

* 乘法运算符、指针解引用运算符(也称为间接寻址运算符)

乘法运算符：a * b;表示将a和b的值相乘，结果存储在c中。
指针类型声明符：char* ptr1;表示声明一个指向字符类型的指针变量ptr1，该变量存储指向字符类型数据的内存地址。
指针解引用运算符/间接寻址运算符：*ptr1表示使用指针变量ptr1存储的地址，从内存中读取它所指向的值。

. 点运算符或成员访问运算符。

访问类的成员变量或成员函数。
访问结构体的成员变量或成员函数。
调用类的静态函数或访问静态变量。
访问命名空间中的变量或函数。

静态成员变量两种访问方式
	//1、通过对象
	Person p1;
	p1.func();
	//2、通过类名
	Person::func();

#include <iostream>
using namespace std;
 
namespace MyNamespace {
    int x;
    void foo() { cout << "Hello from MyNamespace!" << endl; }
};
 
int main() {
	MyNamespace.x = 10;
	MyNamespace.foo();
	return 0;
}

-> 箭头运算符或成员指针访问运算符。

访问类的成员变量或成员函数
访问结构体的成员变量或成员函数
调用类的静态函数或访问静态变量

#include <iostream>
using namespace std;
 
class MyClass {
public:
    static int count;
    static void printCount() { cout << count << endl; }
};
 
int MyClass::count = 10; //静态变量需要在类定义外进行初始化
 
int main() {
	MyClass* p = new MyClass();
	p->count++;
	p->printCount();
	return 0;
}

总结：
符号.和->的作用和区别
A.B则A为对象或者结构体； 点号（.）：左边必须为实体。
A->B则A为指针，->是成员提取，A->B是提取A中的成员B，A只能是指向类、结构、联合的指针； 箭头（->）：左边必须为指针；

符号.和->的作用和区别的原文

: 冒号运算符或成员初始化列表符号。

用于初始化成员变量：在类的构造函数中，可以使用 “:” 运算符来初始化成员变量。
用于调用父类的构造函数：如果一个子类继承自一个父类，那么在定义子类的构造函数时，可以使用 “:” 运算符来调用父类的构造函数。
用于标识基类访问限定符：在派生类中，可以使用 “:” 运算符将基类的 public、protected 或 private 访问限定符进行分类。

1. 用于初始化成员变量
#include<iostream>
using namespace std;
 
class MyClass {
public:
    int a,b,c; // 成员变量
    MyClass(int x, int y, int z):a(x), b(y), c(z){} // 构造函数
};
 
int main() {
    MyClass obj(1, 2, 3); // 创建对象并初始化成员变量
    cout << "a: " << obj.a << endl;
    cout << "b: " << obj.b << endl;
    cout << "c: " << obj.c << endl;
    return 0;
}

2. 用于调用父类的构造函数
#include <iostream>
using namespace std;
 
class Parent {
public:
    Parent(int x) {
        cout << "Parent constructor called with parameter " << x << endl;
    }
};
 
class Child : public Parent {
public:
    Child(int y) : Parent(y) {
        cout << "Child constructor called with parameter " << y << endl;
    }
};
 
int main() {
    Child c(10);
    return 0;
}

将在控制台上输出:
Child constructor called with parameter 10
Parent constructor called with parameter 10

:: 作用域解析运算符或命名空间限定符。（声明或定义时，类静态成员的作用域）

访问命名空间中的变量或函数
访问类中的静态成员变量或静态成员函数
访问全局变量或函数

3. 访问全局变量或函数
#include <iostream>
using namespace std;
 
int global_var = 10; // 全局变量
 
void printGlobalVar() { // 全局函数
    cout << "Global variable: " << global_var << endl;
}
 
class MyClass {
public:
    void printGlobalVar() { // 成员函数
        int global_var = 5; // 局部变量
        cout << "Local variable: " << global_var << endl;
        cout << "Global variable: " << ::global_var << endl; // 使用"::"运算符访问全局变量
        ::printGlobalVar(); // 使用"::"运算符访问全局函数
    }
};
 
int main() {
    MyClass myObj;
    myObj.printGlobalVar();
    return 0;
}

它们的使用场景也各有不同。需要根据具体情况来选择使用哪个运算符。

运算符介绍的原文

总结：

"＆"，"*"，"."、"->"、":"和"::"
& 与 *     和所有数据类型（包括结构体，类）的首地址有关
. 和->     和类，结构体有关（一个是值，一个是地址）
:和::      和类有关（后面一个是访问类的成员函数或属性）

2.3、结构体数组

作用：将自定义的结构体放入到数组中方便维护
语法：struct 结构体名数组名[元素个数]={{}，{}，·{}};

//1、创建结构体数组
struct Student stuArray[3]{
	{"张三",18,100},
	{"李四",28, 99},
	{ "王五",38,66}
};
// 2、给结构体数组中的元素赋值
stuArray[2].name = "赵六";
stuArray[2].age = 80;
stuArray[2].score = 60;
// 3、遍历结构体数组
for (int i = 0; i < 3; i++) {
	cout<< "姓名："<<stuArray[i].name
	    <<"年龄："<<stuArray[i].age
		<< "分数："<< stuArray[i].score<< endl;
}

2.4、结构体指针

作用：通过指针访问结构体中的成员
利用操作符->可以通过结构体指针访问结构体属性

//1、创建学生结构体变量
struct Student s = { "张三",18,100};
//2、通过指针指向结构体变量
struct Student *p =&s;
//3、通过指针访问结构体变量中的数据
cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;

2.5、结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体
例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

//定义学生结构体
struct student{
	string name; // 姓名
	int age;//年龄
	int score; // 分数
};


//定义老师结构体
struct teacher {
	int id;//教师编号
	string name; // 教师姓名
	int age;//年龄
	struct student stu;//辅导的学生
};

//结构体嵌套结构体
//创建老师
struct teacher t;
t.id = 10000;
t.name = "老王";
t.age = 50;
t.stu.name = "小王";
t.stu.age = 20;
t.stu.score = 60;
cout << "老师姓名：" << t.name << "老师编号：" << t.id << "老师年龄：" << t.age
		<< "老师辅导的学生姓名：" << t.stu.name << "学生年龄：" << t.stu.age
		<< "学生考试分数为：" << t.stu.score<<endl;

2.6、结构体做函数参数

作用：将结构体作为参数向函数中传递
传递方式有两种：

值传递
地址传递

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

//值传递
void printStudent(student stu )
{
	stu.age = 28;
	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
}

//地址传递
void printStudent2(student *stu)
{
	stu->age = 28;
	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
}

int main() {

	student stu = { "张三",18,100};
	//值传递
	printStudent(stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;

	cout << endl;

	//地址传递
	printStudent2(&stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;

	system("pause");

	return 0;
}

总结：如果不想修改主函数中的数据，用值传递反之用地址传递

2.7、结构体中const使用场景

作用：用const来防止误操作

将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudents(const student *s)防止函数修改属性值
指针（地址传递）节省空间，值传递会复制一份给函数内的变量。

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

//const使用场景
void printStudent(const student *stu) //加const防止函数体中的误操作
{
	//stu->age = 100; //操作失败，因为加了const修饰
	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;

}

int main() {

	student stu = { "张三",18,100 };

	printStudent(&stu);

	system("pause");

	return 0;
}