网站seo的内容是什么,小区百货店网怎么做网站,动漫人物做羞羞事的网站,wordpress优质主题目录 面向过程和面向对象的初步认识类的引入类的定义类的访问限定符及封装类的作用域类的实例化this指针类的6个默认成员函数构造函数析构函数 面向过程和面向对象的初步认识 C语言是面向过程的#xff0c;关注的是过程#xff0c;分析求解问题的步骤#xff0c;通过函数调用… 目录 面向过程和面向对象的初步认识类的引入类的定义类的访问限定符及封装类的作用域类的实例化this指针类的6个默认成员函数构造函数析构函数 面向过程和面向对象的初步认识 C语言是面向过程的关注的是过程分析求解问题的步骤通过函数调用逐步解决问题 C是基于面向对象的关注的是对象将一件事情拆分成不同的对象靠对象之间的交互完成 C不是纯面向对象的 类的引入
C语言中结构体内只能定义变量在C中结构体内不仅可以定义变量也可以定义函数。C兼容C语言结构体的用法可以继续使用同时struct也升级成了类
struct Stack
{//成员函数void Init(){a nullptr;top capacity 0;}//成员变量int* a;int top;int capacity;
};
void StackInit(struct Stack* ps)
{//....
}
int main()
{struct Stack st1;StackInit(st1);Stack st2;st2.Init();return 0;
}类的定义
class className
{//类体由成员函数和成员变量组成};//注意分号struct和class最主要的区别就是访问限定符 1、类可以做声明和定义分离 Test.cpp Func.cpp: Func.h: 2、类的两种定义方式 1、声明和定义全部放在类体中需要注意成员函数如果在类中定义编译器可以能会将其当成内联函数处理。函数不进入符号表。 2、类的声明放在.h文件当中成员函数定义放在.cpp文件当中注意成员函数之前需要加类名。 类的访问限定符及封装
1、访问限定符public protected private
C实现封装的方式用类将对象的属性和方法结合在一起让对象更加完善荣光访问权限选择性的将其接口提供给外部的用户使用。 1、public 修饰的成员在类外可以直接被访问 2、protected和private修饰的成员在类外不能直接被访问此处protected和private是类似的 3、访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现为止 4、如果后面没有访问限定符作用域到 } 结束 5、class的默认访问权限是privatestruct为public因为struct要兼容C #include iostream
using namespace std;
class Stack
{
public ://成员函数void Init(){a nullptr;top capacity 0;}void push(int x){if (top capacity){int newcapacity capacity 0 ? 4 : 2 * capacity;a (int*)realloc(a, sizeof(int) * newcapacity);capacity newcapacity;}a[top] x;}int Top(){return a[top - 1];}
private://成员变量int* a;int top;int capacity;
};
int main()
{Stack st;st.Init();st.push(1);st.push(2);st.push(3);cout st.Top() endl;return 0;
}2、C中struct和class的区别是什么 C需要兼容C语言所以C中struct可以当成结构体使用另外C中struct还可以用来定义类。和class定义类是一样的。区别是struct定义类的默认访问权限是publicclass定义的类默认访问权限是private。 类的作用域 类定义了一个新的作用域类的所有成员都在类的作用域中。在类体外定义成员时需要使用 :: 作用域操作符指明成员属于哪个类域 类的实例化 1、 用类类型创建对象的过程称为类的实例化 2、类是对对象进行描述的是一个模型一样的东西限定了类有哪些成员定义出一个类并没有分配实际的内存空间来存储它比如入学时填写的学生信息表表格就可以看成是一个类来描述具体学生信息。 3、 一个类可以实例化出多个对象类实例化出的对象占用实际的物理空间类不占用实际的物理空间存储类成员量。 class Date
{
public:void Init(int year, int month, int day){_year year;_month month;_day day;}
private:int _year;int _month; //是类的声明不是类的定义int _day;
};
int main()
{Date d;//实例化开实际的物理空间d.Init(2023, 7, 21);return 0;
}类在内存当中不占内存的空间占文件系统的空间 类不能存储数据类实例化的对象存储数据 对象存储方式 计算类的大小 类中既有成员变量又有成员函数 class A1 {
public:void f1() {} //4
private:int _a;
};类中仅有成员函数 class A2 {
public:void f2() {} //1
};类中什么都没有—空类 class A3 //1
{};分配1字节不存储数据只是占位表示对象存在过 结构体内存对齐规则 第一个成员在与结构体偏移量为0的地址处。其他成员变量要对齐到某个数字对齐数的整数倍的地址处。 注意对齐数 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8结构体总大小为最大对齐数所有变量类型最大者与默认对齐参数取最小的整倍。如果嵌套了结构体的情况嵌套的结构体对齐到自己的最大对齐数的整数倍处结构体的整体大小就是所有最大对齐数含嵌套结构体的对齐数的整数倍。 this指针
class Date
{
public:void Init(int year, int month, int day){cout this endl;_year year;_month month;_day day;}void Print(){cout this endl;cout _year - _month - _day endl;}
private:int _year; int _month;int _day;
};
int main()
{Date d1, d2;d1.Init(2022, 1, 11);d2.Init(2022, 1, 12);d1.Print();d2.Print();return 0;
}此段代码中还隐含了this指针在编译器中编译器会默认给代码加上隐藏的指针参数让该指针指向当前对象(函数运行时调用该函数的对象)在函数体中所有“成员变量”的操作都是通过该指针去访问。只不过所有的操作对用户是透明的即用户不需要来传递编译器自动完成。 上述程序代码中两个成员函数的指针并不是同一个更准确的来说是看this指针指向哪个对象如何指向的是d1对象那么调用两个成员函数的地址就是相同的。如果同时调用两个对象所指向的成员函数那么this指针的地址就是不同的。 this指针指向当前调用的对象是临时变量函数调用结束后就销毁了 练习题1
class A
{
public:
void Print()
{
cout Print() endl;
}
private:
int _a;
};
int main()
{
A* p nullptr;
p-Print();
return 0;
}运行成功打印Print( )该函数存放在公共代码区不存到成员变量中所以p指针不解引用运行成功 练习题2
class A
{
public:void PrintA(){cout_aendl;}
private:
int _a;
};
int main()
{A* p nullptr;p-PrintA();return 0;
}运行崩溃此处有空指针的解引用因为函数存放在公共代码区p指针不解引用是空同时this指针也是空导致程序运行崩溃 this指针存放在哪 this指针是一个形参一般存在栈栈帧中。VS下面一般会用ecx寄存器直接传递 this指针的特性 this指针的类型类类型* const即成员函数中不能给this指针赋值。只能在“成员函数”的内部使用this指针本质上是“成员函数”的形参当对象调用成员函数时将对象地址作为实参传递给this形参。所以对象中不存储this指针。this指针是“成员函数”第一个隐含的指针形参一般情况由编译器通过ecx寄存器自动传递不需要用户传递 类的6个默认成员函数 如果一个类当中什么都没有那么这个类就是空类但是空类在什么都不写的情况下会自动生成以下6个默认成员函数。 默认成员函数用户没有显式实现编译器会生成的成员函数称为默认成员函数。 默认构造函数的特点不传参就可以调用的构造就是默认构造 class classmate
{};构造函数
特性构造函数是特殊的成员函数构造函数虽然名称叫构造但是构造函数的主要任务并不是开空间创建对象而是初始化对象。 特性 1、函数名与类名相同 2、无返回值 也不需要写void 3、对象实例化时编译器自动调用对应的构造函数 4、构造函数可以重载 可以写多个构造函数提供多种初始化方式 class Date
{
public:Date()//无参构造函数{_year 1;_month 1;_day 1;}Date(int year, int month, int day)//有参构造函数{_year year;_month month;_day day;}void Init(int year, int month, int day){_year year;_month month;_day day;}void Print(){cout _year - _month - _day endl;}
private:int _year;int _month;int _day;
};上述构造函数也可以合并写成参数全缺省形式
class Date
{
public://Date()//无参构造函数//{// _year 1;// _month 1;// _day 1;//}//Date(int year, int month, int day)//有参构造函数//{// _year year;// _month month;// _day day;//}Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}void Init(int year, int month, int day){_year year;_month month;_day day;}void Print(){cout _year - _month - _day endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Print();Date d2(2023,7,28);d2.Print();Date d3(2023, 7);d3.Print();/*d1.Init(2022, 7, 5);d1.Print();Date d2;d2.Init(2022, 7, 6);d2.Print();*/return 0;
}C实现栈
#include assert.hclass Stack
{
public:/*Stack(){a nullptr;top capacity 0;}*/Stack(size_t n 4){if (n 0){a nullptr;top capacity 0;}else{a (int*)malloc(sizeof(int) * n);if(a nullptr){perror(realloc fail);exit(-1);}top 0;capacity n;}}// 成员函数//void Init()//{// a nullptr;// top capacity 0;//}void Push(int x){if (top capacity){size_t newcapacity capacity 0 ? 4 : capacity * 2;int* tmp (int*)realloc(a, sizeof(int) * newcapacity);if (tmp nullptr){perror(realloc fail);exit(-1);//程序以异常的方式退出}if (tmp a){cout capacity 原地扩容 endl;}else{cout capacity 异地扩容 endl;}a tmp;capacity newcapacity;}a[top] x;}int Top(){return a[top - 1];}void Pop(){assert(top 0);--top;}void Destroy(){free(a);a nullptr;top capacity 0;}bool Empty(){return top 0;}
private:// 成员变量int* a;int top;int capacity;
};int main()
{Stack st1;st1.Push(1);st1.Push(2);st1.Push(3);st1.Push(4);while (!st1.Empty()){cout st1.Top() ;st1.Pop();}cout endl;st1.Destroy();//Stack st2(1000);Stack st2;for (size_t i 0; i 1000; i){st2.Push(i);}while (!st2.Empty()){cout st2.Top() ;st2.Pop();}cout endl;st2.Destroy();
} 推荐在一个类当中使用全缺省构造函数 构造函数也是默认成员函数我们不写编译器会自动生成 编译生成的构造函数的特点 1、我们不写才会自动生成我们写了就不会自动生成了 2、内置类型基本类型 int double成员不会处理C11声明支持给缺省值 3、对于自定义类型的成员才会处理会去调用这个成员的默认构造函数 如果类中没有显示定义构造函数则C编译器会自动生成一个无参的默认构造函数一旦用户显示定义编译器将不再生成。 无参的构造函数和全缺省的构造函数都称为默认构造函数并且默认构造函数只能有一个多个并存会存在调用的二义性。 注意无参构造函数全缺省构造函数我们没有写编译器默认生成的构造函数都可以认为时默认构造函数不传参就可以调用的。 一般情况下都需要我们自己写构造函数决定初始化方式 class Time
{
public:Time(){cout Time() endl;_hour 0;_minute 0;_second 0;}
private:int _hour;int _minute;int _second;
};
int main()
{//MyQueue mq;Time t;return 0;
}举例
class A
{
public:A(int a){cout A(int a) endl;}
private:int _a;
};
class Date
{
public:Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}
private:int _year;int _month;int _day;A _aa;};
int main()
{Date d1;//Date d2(2023, 7, 29);return 0;
}运行报错 错误原因类A中不存在默认构造函数默认构造函数无参的构造函数和全缺省的构造函数。 代码更正将类A中的构造函数写成参数全缺省形式
class A
{
public:A(int a1){cout A(int a) endl;}
private:int _a;
};
class Date
{
public:Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}
private:int _year;int _month;int _day;A _aa;};
int main()
{Date d1;//Date d2(2023, 7, 29);return 0;
}析构函数
析构函数与构造函数功能相反析构函数不是完成对对象本身的销毁局部对象销毁工作是编译器完成的。而对象在销毁时会自动调用析构函数完成对象中资源的清理工作。 特性 1、析构函数名是在类名前加上字符“~” 2、无参数无返回值类型 3、一个类只能有一个析构函数若未显式定义系统会自动生成默认的析构函数。注意析构函数不能重载 4、对象生命周期结束时C编译系统自动调用析构函数 默认的析构函数 对内置类型成员不做处理 自定义类型的成员会去调用他的析构函数 class Time
{
public:Time(){cout Time() endl;_hour 0;_minute 0;_second 0;}~Time(){cout ~Time() endl;}
private:int _hour;int _minute;int _second;
};
int main()
{Time t;return 0;
}栈需要显式的写析构函数
class Stack
{
public://构造函数Stack(size_t n 4)//unsigned int{if (n 0){a nullptr;top capacity 0;}else{a (int*)malloc(sizeof(int) * n);if (a nullptr){perror(malloc fail);exit(-1);//异常}top 0;capacity n;}}int Top(){return a[top - 1];}void Pop(){assert(top 0);top--;}void Push(int x){if (top capacity){size_t newcapacity capacity 0 ? 4 : capacity * 2;int* tmp (int*)realloc(a, sizeof(int) * newcapacity);if (tmp nullptr){perror(realloc fail);exit(-1);}if (tmp a){cout capacity 原地 endl;}else{cout capacity 异地 endl;}a tmp;capacity newcapacity;}a[top] x;}~Stack(){cout ~Stack() endl;free(a);a nullptr;top 0;capacity 0;}bool Empty(){return top 0;}
private:int* a;int top;int capacity;
};
int main()
{Stack st1(1000);st1.Push(1);st1.Push(2);while (!st1.Empty()){cout st1.Top() endl;st1.Pop();}return 0;
}默认析构函数 1、内置类型成员不会处理 2、自定义类型成员会调用这个成员的析构函数 C实现括号匹配
#include iostream
#include assert.h
using namespace std;class Stack
{
public:Stack(size_t n 4)//构造函数{cout Stack(size_t n 4) endl;if (n 0){a nullptr;top capacity 0;}else{a (int*)malloc(sizeof(int) * n);if (a nullptr){perror(realloc fail);exit(-1);}top 0;capacity n;}}~Stack()//析构函数{cout ~Stack() endl;free(a);a nullptr;top capacity 0;}void Push(int x){if (top capacity){size_t newcapacity capacity 0 ? 4 : capacity * 2;int* tmp (int*)realloc(a, sizeof(int) * newcapacity);if (tmp nullptr){perror(realloc fail);exit(-1);}if (tmp a){cout capacity 原地扩容 endl;}else{cout capacity 异地扩容 endl;}a tmp;capacity newcapacity;}a[top] x;}int Top(){return a[top - 1];}void Pop(){assert(top 0);--top;}void Destroy(){free(a);a nullptr;top capacity 0;}bool Empty(){return top 0;}
private:// 成员变量int* a;int top;int capacity;
};
bool isValid(const char* s) {Stack st;while (*s){if (*s [ || *s ( || *s {){st.Push(*s);s;}else{// 不匹配if (st.Empty())return false;char top st.Top();st.Pop();// 不匹配if ((*s ] top ! [)|| (*s ) top ! ()|| (*s } top {)){return false;}s;}}return st.Empty();
}int main()
{// 后定义先析构Stack st1;Stack st2;cout isValid([[]]()()) endl;cout isValid([[]]]) endl;return 0;
}
