C++笔记

1 类和对象

 1.1 封装

• 将属性和行为表现为一个整体，展现生活中的十五
• 将属性和行为加以权限控制

 1.1.1 封装的意义（一）

  在设计类的时候，属性和行为写在一起，表现事物

  语法 ：class 类名  {  访问权限：  属性  /  行为  }；

#include<iostream>
using namespace std;

//设计一个学生类，属性有姓名和学号，可以赋值并显示

class Student
{
public:   //公共权限

	//类中的属性和行为 统一称为 成员
	//属性    成员属性 成员变量
	//行为    成员函数 成员方法

	//属性
	string m_Name;
	int m_Id;

	//行为
	//显示姓名和学号
	void showStudent()
	{
		cout << "姓名："<< m_Name << "\t学号" << m_Id << endl;
	}
	
	//给姓名赋值
	void setName(string name)
	{
		m_Name = name;
	}

    //给学号赋值
	void setID(double id)
	{
		m_Id = id;
	}

private:

};

int main()
{

	//创建一个具体学生 实例化对象
	Student s1;
	//给s1对象 进行属性赋值操作
	s1.setName("J-dub");
	s1.setID(202301);
	s1.showStudent();

	Student s2;
	s2.m_Name = "sym";
	s2.m_Id = 1722730069;
	s2.showStudent(); 


	system("pause");
	return 0;
}

 1.1.2 封装的意义（二）

  类在设计时，可以把属性和行为放在不同的权限下，加以控制

  访问权限有三种：

1. public         公共权限  
2. protected   保护权限（父亲的车）
3. private       私有权限（父亲银行卡的密码）

class Person
{
public:
	//公共权限
	string m_Name;//姓名

protected:
	//保护权限
	string m_Car;//汽车

private:
	//四有权限
	int m_Password;

public:     //如果是protected、private，类外访问不了函数
	void func()
	{
		m_Name = "张三";
		m_Car = "mecedes";
		m_Password = 123456;  //类内可以访问
	
	 }
};

int main() {
	
	//实例化具体对象
	Person p1;

	p1.m_Name = "marco";
	//p1.m_Car = "benz";     保护权限内容，类外不可访问
	//p1.m_Password = 123;   私有权限内容，类外不可访问

	p1.func();

	system("pause");
	return 0;
}

1.1.3成员函数和全局函数

2 指针

2.1 const修饰指针——常量指针

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

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

---

3 静态局部变量

void fun04()
{
static int num=10;
num++;
cout<<"num = "<<num<<endl;
}
int main()
{
fun04();//num = 11
fun04();//num = 12
fun04();//num = 13
fun04();//num = 14
}

作用范围：所在的{}复合语句之间有效

生命周期：整个进程有效

存储区域：全局区

注意事项： 1、静态局部变量不初始化 内容为0

                   2、静态局部变量 整个进程 都存在（第一次定义有效）

---

4  指针

4.1指针变量

地址 就是内存的地址编号。 指针变量：本质是变量 只是该变量 保存的是 内存的地址编号。（不是普通的数值）

#include <stdio.h>

// 定义一个结构体类型
struct Person {
    char name[50];
    int age;
    float height;
};

int main() {
    // 创建结构体变量并初始化
    struct Person person1;
    strcpy(person1.name, "John");
    person1.age = 30;
    person1.height = 175.5;

    // 访问结构体变量的成员
    printf("Name: %s\n", person1.name);
    printf("Age: %d\n", person1.age);
    printf("Height: %.2f\n", person1.height);

    // 创建另一个结构体变量
    struct Person person2;
    strcpy(person2.name, "Alice");
    person2.age = 25;
    person2.height = 162.0;

    printf("\nName: %s\n", person2.name);
    printf("Age: %d\n", person2.age);
    printf("Height: %.2f\n", person2.height);

    return 0;
}

5 结构体

5.1 const使用场景

//将函数中的形参改为指针，可以减少内存空间，而且不会复制出新的副本出来
void printStudents (student *s )
{
   s->age=150;
   cout<<"name:"<< s->name<<endl;
}

--printStudents ( &s);--

在函数体中进行了写操作，为了防止结构体中的数据被修改，加const

//将函数中的形参改为指针，可以减少内存空间，而且不会复制出新的副本出来
void printStudents ( const student *s )
{
   //s->age=150;  //加入const之后，一旦有修改的操作就会报错
   cout<<"name:"<< s->name<<endl;
}

--printStudents ( &s);--