C++学习笔记（3）

目录

一.C++类和对象的基本概念

二.类的定义

1.创建语法

2.权限限定

三.对象的创建和访问

四.面向对象的编程方式

---

一.C++类和对象的基本概念

什么是类?什么是对象?（以下为本人的粗浅理解）

        类是一系列事物的抽象，万物皆可为类，而对象则是类的实体。举个简单的例子，我们可以把路上来来往往的车辆抽象成一个 “车类” ，在这个类里面，这些车的共同特征都是这个类的 “属性”，比如，这些车都有车轮，都有颜色，都有车主...等等，这些特征虽然具体内容可能大家都不一样，但是大家都有这个特征，也就是类的属性；而车子都能加速减速，这些基于对象而实现的操作叫 “行为” ，这些行为是类里面大家都能做到的，你是 “车” 我也是 “车” ，都能实现这些操作，这时候我们就能把这些操作抽象封装起来，成为这个类的行为。所以说，类是由两部分组成的——属性和行为。属性一般由数据类型描述，而行为一般由函数描述。

        对象就是类的实例化，具体化。类的特点是：封装，继承，多态。封装可能大家学了C语言会比较熟悉，实际上结构体就是蕴含着封装的思想，而继承和多态具体怎么理解？这里就不展开叙述，后续都会讲解说明。（实际上是因为不结合实例很容易忘，而要结合实例就要往下学，不能卡在这）对于初学我觉得应该循序渐进，点到为止，坚持学下去，就会有收获！

二.类的定义

1.创建语法

class 类名
{

};

2.权限限定

        在声明一个类的时候，可以对类的成员的访问权限做出限定，分别有 “pubic” “private” “protected” 这三个，这三个修饰符可以决定外部其他类或函数是否可以访问本类中的成员变量或者函数。

        public：修饰共有属性，一般来说，可以把对事物的操作，也就是函数放在里面。

        private：修饰私有属性，一般我们把数据类型放在私有域中，保证它不会被乱改，要修改可以通过接口函数实现。

        protected：在没学习继承之前，跟private是一样的，区别就是在学了继承之后，protected中的东西可以被子类访问，而private不行，这里不理解没关系，后面的文章会补充更新这块内容。

class 类名
{
public:
	//共有属性
	//成员函数
	void printData();
protected:
	//保护属性
	//数据成员
	string m_name;
	int m_age;
private:
	//在不做继承处理时，跟private一样
};

         C++中，结构体在一定程度上也可以直接当作类来使用，也可以使用权限限定词修饰，不过结构体的默认属性是 “public” ，而类的默认属性是 “private” 。

        关于权限访问的规定：类外只能访问 “public” 下的东西，并且类外访问类中的public数据只能通过对象访问，如果想访问private或者protected的数据，需要通过public中的接口函数，具体如下：

class A
{
public:
	void printData()
	{
		cout << m_name << " " << m_age << endl;
	}
	void initData(string name, int age)
	{
		m_name = name;
		m_age = age;
	}
protected:
	string m_name;
	int m_age;
};
int main()
{
	A a;
	a.initData("小蓝", 18);
	a.printData();
}

于是就可以成功打印啦！

三.对象的创建和访问

其实在上面的实例中，我已经用到了对象的创建和访问了，这里就再总结一下吧！

A a;            //普通单个对象
A arr[4];       //多个对象，对象数组
A* ap = new A;  //著名的“new”一个对象

其实你会发现，跟结构体简直不要太像！（所以new出来的记得delete哦！方法是一样的）

如何进行初始化？

还没学构造函数之前有两种方式（构造函数是什么？别问，问就是下一篇会讲）

1.通过提供公有接口传参的方式来初始化数据

class A
{
public:
	void initData(string name, int age)
	{
		m_name = name;
		m_age = age;
	}
protected:
	string m_name;
	int m_age;
};
int main()
{
	A a;
	a.initData("小蓝", 18);
}

2.通过提供公有接口返回引用的方式来初始化数据

class A
{
public:
	int& getAge()
	{
		return m_age;
	}
	string& getName()
	{
		return m_name;
	}
protected:
	string m_name;
	int m_age;
};
int main()
{
	A a;
	a.getAge() = 18;
	a.getName() = "小蓝";
}

3.也可以直接在类里面初始化

class A
{
public:
protected:
	string m_name = "小蓝";
	int m_age = 18;
};

四.面向对象的编程方式

        学了到这里终于要开始进入传说中的面向对象了，面向对象是怎么样的呢？我们来以我们最熟悉的链表为例，分别看看面向过程和面向对象是怎么实现的。

先看我们熟悉的实现方式，来创建一个有表头的链表：

struct Node
{
	int data;
	Node* next;
};
//创建链表
struct Node* createList()
{
	Node* headNode = new Node;
	headNode->next = nullptr;
	return headNode;
}
//创建节点
struct Node* createNode(int data)
{
	Node* newNode = new Node;
	newNode->next = nullptr;
	newNode->data = data;
	return newNode;
}
//头插法
void insertHead(struct Node* head, int data)
{
	Node* newnode = createNode(data);
	newnode->next = head->next;
	head->next = newnode;
}
//打印
void printList(struct Node* head)
{
	Node* p = head->next;
	while (p)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
int main()
{
	Node* List = createList();
	insertHead(List, 10);
	insertHead(List, 20);
	printList(List);
	delete List;
}

可以看到，函数的实现都是在外部实现，然后要调用的时候再把它们穿起来，再来看看面向对象的方式：

struct Node
{
	int data;
	Node* next;
};
class List
{
public:
	//初始化链表,访问私有域
	void initList()
	{
		headNode = new Node;
		headNode->next = nullptr;
	}
	//头插法
	void insertHead(int data)
	{
		Node* newNode = new Node;
		newNode->data = data;
		newNode->next = nullptr;

		newNode->next = headNode->next;
		headNode->next = newNode;
	}
	//打印
	void printList()
	{
		Node* p = headNode->next;
		while (p)
		{
			cout << p->data << " ";
			p = p->next;
		}
		cout << endl;
	}
	//销毁链表
	void deleteList()
	{
		Node* p = headNode,*q;
		while (p)
		{
			q = p;
			p = p->next;
			delete q;
		}
	}
private:
	Node* headNode;
};
int main()
{
	List list;
	list.initList();
	list.insertHead(10);
	list.insertHead(20);
	list.printList();
	list.deleteList();
}

可以看到，面向对象的方式就是把想干的事封装起来，统一直接用对象去操作。

今天就到这吧，明天更新构造函数部分，加油吖！