入门知识已经梳理完毕了,接下来就进入到面型对象的部分学习了
C语言典型的面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题
C++是典型的基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。
将大象和冰箱看作两个对象,每个对象都有自己的特征和行为 首先,冰箱可能有一个开门和关门的方法,而大象可能有一个“装进冰箱”的方法。在这种情况下,你会调用冰箱的“开门”方法,然后调用大象的“装进冰箱”方法,最后再调用冰箱的“关门”方法
C语言结构体中只能定义变量 。在C++中,结构体内不仅可以定义变量,也可以定义函数。比如:之前在数据结构初阶中,用C语言方式实现的栈,结构体中只能定义变量;现在以C++方式实现,会发现struct中也可以定义函数
之前c:
struct Stack
{
int* a;
int top;
int capacity;
//功能函数只能在外面
};
现在C++:
struct Stack
{
int* a;
int top;
int capacity;
void Init(size_t capacity)
{
//
}
void Push(const DataType& data)
{
// 扩容
_array[_size] = data;
++_size;
}
//............
};
而C++里sturct会用class来代替
C++兼容c语言struct的所有用法,struct同时升级成了类。 注意:
class ClassName {
public:
// 公有成员函数和变量
// 可以被类外部访问
private:
// 私有成员函数和变量
// 只能被类内部成员函数访问
protected:
// 保护成员函数和变量
// 类的继承者可以访问
};
class为定义类的关键字,ClassName为类的名字,
{ }
中为类的主体,注意类定义结束时后面分号不能省略。类体中内容称为类的成员:类中的变量称为类的属性或成员变量 ; 类中的函数称为类的方法或者成员函数。
需注意:成员函数如果在类中定义,编译器可能会将其当成内联函数处理(当然这里也是建议,具体还是要看编译器)
class Stack
{
private:
int* a;//这三个变量都是声明,内存没有给他们分配空间,创建对象后才有空间
int top;
int capacity;
public:
void Init(size_t capacity)//声明和定义都在类内
{
a = nullptr;
top = -1;
capacity = 0;
}
//............
};
在类内只进行声明,定义在类外
一般:类声明放在.h文件中,成员函数定义放在.cpp文件中 注意:成员函数名前需要加类名 : :(感觉跟命名空间一个用法)
class Stack
{
private:
int* a;
int top;
int capacity;
public:
void Init(size_t capacity);//类内声明
//............
};
void Stack::Init(size_t capacity)//类外定义 注意加上 类名::
{
a = nullptr;
top = -1;
capacity = 0;
}
有时候会有这种情况:
class Date
{
private:
int year;
int mouth;
int day;
public:
void Init(int year, int mouth, int dat)
{
year = year;//我们大多时会习惯于相同变量名,现在就遇到疑惑了
//......
}
};
为了避免上述情况,我们习惯于在成员变量前加**
_
**(大家默许的规定吧) int _year; int _mouth;
在上面的代码里大家看到了private、public之类的,现在就来讲它们:
C++实现封装的方式:用类将对象的属性与方法结合在一块,让对象更加完善,通过访问权限选择性的将其接口提供给外部的用户使用
访问限定符说明:
注意:访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别
我们大家都知道面向对象的三大性质:封装、继承、多态
在类和对象阶段,主要是研究类的封装特性,那什么是封装呢?
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互 封装本质上是一种管理,让用户更方便使用类
类定义了一个新的作用域,类的所有成员都在类的作用域中。在类体外定义成员时,需要使用
::
作用域操作符指明成员属于哪个类域
class Date
{
private:
int _year;
int _mouth;
int _day;
public:
void Init(int year, int mouth, int day);
};
void Date::Init(int year, int mouth, int day)
{
_year = year;
}
用类类型创建对象的过程,称为类的实例化(类 和 对象是 1对多的关系)
蓝图没有空间,你怎么能放数据进去呢? 所以需要实例化后,再进行赋值等一系列操作
只保存成员变量,成员函数存放在公共的代码段(成员函数的地址不在对象中,成员变量是在的)
结论:一个类的大小,实际就是该类中”成员变量”之和,当然要注意内存对齐 注意空类的大小,空类比较特殊,编译器给了空类一个字节来唯一标识这个类的对象
关于内存对齐,我这篇文章详细讲了:c语言进阶部分详解(详细解析自定义类型——结构体,内存对齐,位段)
class Date
{
public:
void InitDate(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void PrintDate()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2;
d1.InitDate(2024, 1, 2);
d2.InitDate(2023, 1, 2);
d1.PrintDate();
d2.PrintDate();
return 0;
}
有一个问题:Date类中有 Init 与 Print 两个成员函数,函数体中没有关于不同对象的区分,那当d1调用 Init 函数时,该函数是如何知道应该设置d1对象,而不是设置d2对象
C++中通过引入this指针解决该问题,即:C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有“成员变量”的操作,都是通过该指针去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成
所以实际上:
class Date
{
public:
// 不能显示的写实参和形参
// void Print(Date* const this),这样不行
void Print()
{
//this = nullptr; this实际上穿过来了
cout << this << endl;
// 但是可以在类里面显示的使用
cout << this->_year << "-" << this->_month << "-" << this->_day << endl;//写出来也没事
cout << _year << "-" << _month << "-" << _day << endl;//正常是这样,不用写
}
private:
int _year=1; // 年
int _month=1; // 月
int _day=1; // 日
};
class A
{
public:
void print()
{
cout << "print()";
}
private:
int _a;
};
int main()
{
A* a = nullptr;//现在是空指针
a->print();
return 0;
}
可以运行成功:实际上没有对a进行解引用操作和指向空间的访问
class A
{
public:
void print()
{
cout << "print()" << endl;
cout << _a;//多了这个,对a指向的空间访问
}
private:
int _a;
};
int main()
{
A* a = nullptr;//现在是空指针
a->print();
return 0;
}
今天就到这里了,下次给大家详细介绍构造函数和析构函数,感谢支持!!!