企业官网建设流程全解析

// 数据结构——栈（stack）的实现 // C语言 // Stack不是结构体类型名，struct Stack才是 typedef struct Stack { // 结构体的主体仅有成员变量 int* arr; int top; int capacity; }ST; // typedef重命名结构体类型名struct Stack为ST // C语言只能在结构体外部定义函数 void push(ST* ps, int x) { //... } // 压栈方法 void pop(ST* ps) { //... } // 出栈方法 int top(ST* ps) { //... } // 访问栈顶方法 // C++ // 无需typedef重命名，类名Stack即类类型名称 class Stack // 类的书写格式：class + 类名 + {} + ; { public: // 除了成员变量，类中还可以定义成员函数 void push(int x) { // ... } // 压栈 void pop() { // ... } // 出栈 int top() { // ... } // 获取栈顶元素 // 成员变量 int* arr; int top; int capacity; }; // 分号不能省略！ int main() { // C语言 // 定义变量要用类型名称，Stack是结构体名称，struct Stack是结构体类型名称 struct Stack st1; // 使用typedef重命名结构体类型名称为ST ST st2; // 访问结构体中的成员变量 st2->top = 0; // 调用压栈方法 push(&st2, 0); // 方法未封装，需要传结构体变量的地址 // C++ // 类名Stack即类类型名，无需加上struct或class，也无需typedef Stack st3; // Stack类的对象访问成员变量 st3.top = 0; // 调用压栈方法 st3.push(0); // 方法被封装，无需手动传地址，直接调用 return 0; }

class Stack { public: // 顶格写，后面跟冒号 // 冒号之后到下一个限定符前，都是public // 成员函数 void push(int x) {} void pop() {} void top() {} private: // 顶格写，后面跟冒号 // 冒号之后到右花括号}，都是private // 成员变量 int* arr; int top; int capacity; };

class Stack { // {到第一个限定符public都是私有 void push(int x) {} public: // 该位置到下一个限定符private都是公有 void pop() {} private: // 该位置到下一个限定符public都是私有 void top() {} public: // 该位置到下一个限定符protected都是公有 int* _arr; int _top; protected: // 该位置，到右花括号}都是保护 int _capacity; }; int main() { Stack st; st.push(); // push方法是私有，不能类外访问 st.pop(); // pop方法是公有，可以类外访问 st.top(); // top方法是私有，不能类外访问 st._arr; // 成员变量_arr是公有，可以类外访问 st._top; // 成员变量_top是公有，可以类外访问 st._capacity;// 成员变量_capacity是保护，不能类外访问 return 0; }

// 结构体升级成了类 struct Stack { // 默认访问权限为public // struct中可以有成员函数、访问限定符等 void push(int x) {} void pop() {} void top() {} private: // 成员变量 int* arr; int top; int capacity; }; int main() { // 无需typedef了，struct定义的也是类，类名就是类型名称 Stack st; // 兼容C语言的用法，也可以在名称前加struct作为类型名称 struct Stack st; return 0; } struct ListNode { int val; // 在结构体内部定义该结构体类型的变量 // 1.C语言的写法，struct ListNode才是结构体类型名称 // struct ListNode* next; // 必须加struct，typedef也不行 // 2.C++的写法，类名就是类型名称 ListNode* next; // 这种写法C语言中是报错的 };

#include<iostream> class Date { // 成员函数Init、Print和成员变量_year,_month,_day都属于Date类域 public: void Init() { _year = 2025; _month = 1; _day = 1; } // 成员函数Print声明与定义分离 void Print(); // 类中声明Print方法 public: // 成员变量 int _year; // 年 int _month; // 月 int _day; // 日 }; void Date::Print() // 类外定义Print方法，必须使用域操作符::指明所属类域 { std::cout << _year << "年" << _month << "月" << _day << "日" << std::endl; } int main() { Date d; d.Init(); // 将Date类对象d年月日置为2025年1月1日 d.Print(); // 打印日期 return 0; }

#include<iostream> using namespace std; class Date { public: void Init() { _year = 2025; _month = 1; _day = 1; } void Print(); // Print方法的声明 public: int _year; // 年 int _month; // 月 int _day; // 日 }; // 类外定义Print void Print() { cout << _year << "年" << _month << "月" << _day << "日" << endl; }

// 函数调用的本质是call 地址 #include<iostream> using namespace std; class Date { public: 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 d; // 如下面两条函数调用语句，函数调用都会被翻译成汇编指令call<函数地址> // 编译器在链接阶段就已经确定<函数地址>，程序运行阶段，执行该代码时直接调用即可 d.Init(2024, 3, 31); // call Init成员函数的地址 d.Print(); // call Print成员函数的地址 return 0; }

#include<iostream> using namespace std; // 计算⼀下A/B/C/D实例化的对象是多⼤？ // A类 class A { public: void Print() {cout << _ch << endl;} private: char _ch; int _i; }; // B类 class B { public: void Print() {} }; // C类 class C {}; // D类 class D { public: void Print() {cout << _ch << endl;} private: char _ch; int _i; A _a; }; int main() { A a; B b; C c; D d; // 计算a、b、c、d的大小 cout << sizeof(a) << endl; cout << sizeof(b) << endl; cout << sizeof(c) << endl; cout << sizeof(d) << endl; return 0; }

之前的代码示例中，其实我们回避了一个问题，成员函数既然是各个对象所共享的，那是怎么区分哪个对象调用的函数呢？怎么传的参数呢？如下：

代码示例 1.6.1

#include<iostream> using namespace std; class Date { public: void Init(int year, int month, int day) { // 函数内部看起来并未特别区分，如何知道_year/_month/_day属于哪个对象呢？ // 如果有多个Date类对象d1、d2，如何区分d1->_year与d2->_year？ _year = year; _month = month; _day = day; } void Print() { // 如何区分？ cout << _year << "/" << _month << "/" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; Date d2; // d1,d2共用相同成员函数，Init和Print // 成员函数内部似乎没有特别区分，类外调用函数也没有像C语言一样传对象地址 d1.Init(2024, 3, 31); // 没有像C语言一样传地址/传参，如Init(&d1, 2024, 3, 31); d1.Print(); // 没有Print(&d1); d2.Init(2024, 7, 5); // 没有Init(&d2, 2024, 7, 5); d2.Print(); // 没有Print(&d2); return 0; }

代码示例 1.6.2

class Date { public: // 默认在第一个形参前隐式增加，编译器完成，不需要自己写，形参列表也看不见 // 自己类类型的指针，例如Date类的this指针就是Date*，A类的this指针是A* // const修饰是为了确保this指针的指向不能改变，this指针始终指向调用该成员函数的对象 void Init(int year, int month, int day) { _year = year; // 实际上是this->_year = year; _month = month; // 实际上是this->_month = month; _day = day; // 实际上是this->_day = day; // 可以显式的用this指针，上下两种使用方式都可以，上面方便，字少 this->_year = year; this->_month = month; this->_day = day; // 同时注意，this指针的指向无法修改 // 例如将this指针设为空指针 // this = nullptr; // 例如指针运算 // this++; } // 真实原型为void Print(Date* const this) void Print() { // 两种都可以，不管是否显式的写this指针，编译器都是通过this指针访问的成员变量 cout << _year << "/" << _month << "/" << _day << endl; cout << this->_year << "/" << this->_month << "/" << this->_day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; Date d2; // 其实编译器偷偷的把对象的地址传给了this指针 d1.Init(2024, 3, 31); // 本质和Init(&d1, 2024, 3, 31)类似，只是由编译器完成 d1.Print(); // Print(&d1); d2.Init(2024, 7, 5); // Init(&d2, 2024, 7, 5); d2.Print(); // Print(&d2); return 0; }

#include<iostream> using namespace std; class Date { public: // 不能在形参位置显式的写this指针 // 例如，void Init(Date* const this, int year, int month, int day) void Init(int year, int month, int day) { _year = year; _month = month; _day = day; } // 不能显式写，void Print(Date* const this) void Print() { cout << _year << "/" << _month << "/" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; Date d2; // 通过点操作符.调用成员函数时，操作符前的d1、d2对象被编译器传参传给了隐式的this指针 // 不能在实参位置显式传参给this指针，例如 // d1.Init(&d1, 2024, 3, 31)或Init(&d1, 2024, 3, 31) // 前者是形参过多，点操作符前的d1已经传参给this指针，&d1就是多余形参传给了year // 后者其实是在调用全局函数，而Init在类里，因此会出现函数不存在的情况，没有该全局函数 // 类的成员不能直接访问，必须通过对象或类类型指针间接访问 d1.Init(2024, 3, 31); d1.Print(); d2.Init(2024, 7, 5); d2.Print(); return 0; }

#include<iostream> using namespace std; class A { public: void Print() { cout << "A::Print()" << endl; } private: int _a; }; int main() { A* p = nullptr; p->Print(); return 0; }

#include<iostream> using namespace std; class A { public: void Print() { cout << "A::Print()" << endl; cout << _a << endl; } private: int _a; }; int main() { A* p = nullptr; p->Print(); return 0; }

（3）、this指针存在内存的哪个区域中？（）

A.堆 B.栈 C.静态区 D.常量区 E.对象里面

代码示例 2.1

// C语言实现Stack #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #include<assert.h> typedef int STDataType; // 重命名，方便随手修改栈中的数据类型 typedef struct Stack // 定义一个结构体类型代表栈类型 { STDataType* data; // 数组，存储栈中数据 int top; // top为栈顶，即数组末尾元素的下一个位置 int capacity; // 栈的空间容量，记录栈最多可存储的元素个数 }ST; // typedef重命名结构体类型struct Stack为ST // 栈的初始化方法 void STInit(ST* ps) // 形参ps接收栈变量的地址 { assert(ps); // 检查ps指针是否为空，为空会报错强制中断程序 ps->data = NULL; ps->top = 0; ps->capacity = 0; } // 栈的销毁方法 void STDestroy(ST* ps) { assert(ps); // 动态申请的内存需要手动释放，free数据空间 free(ps->data); ps->data = NULL; ps->top = ps->capacity = 0; } // 压栈方法 void STPush(ST* ps, STDataType x) { assert(ps); // 插入数据前判断是否满栈 if (ps->top == ps->capacity) { // capacity为0，新空间大小newcapacity置为4，否则2倍扩容 int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2; // 动态申请内存空间 STDataType* tmp = (STDataType*)realloc(ps->data, newcapacity * sizeof(STDataType)); // 判断是否成功扩容 if (tmp == NULL) { // 开辟失败，报错提示并返回 perror("realloc fail"); return; } // 开辟成功，更新数据空间及其大小 ps->data = tmp; ps->capacity = newcapacity; } // 未满栈或扩容成功，数据入栈，同时更新栈顶top ps->data[ps->top++] = x; } // 判断空栈方法 bool STEmpty(ST* ps) { assert(ps); return ps->top == 0; // 栈顶为0说明栈中没有元素，空栈返回true，否则false } // 出栈方法 void STPop(ST* ps) { assert(ps); // 判断是否空栈，空栈无法出栈 assert(!STEmpty(ps)); // 出栈 ps->top--; } // 获取栈顶数据方法 STDataType STTop(ST* ps) { assert(ps); assert(!STEmpty(ps)); // 返回栈顶数据，top为末尾元素的下一位置，top-1即末尾元素 return ps->data[ps->top - 1]; } // 获取栈中数据个数方法 int STSize(ST* ps) { assert(ps); return ps->top; } int main() { ST s; // 定义一个栈变量 STInit(&s); // 传栈变量地址，初始化 // 插入数据 STPush(&s, 1); STPush(&s, 2); STPush(&s, 3); STPush(&s, 4); // 输出栈中所有数据 while (!STEmpty(&s)) // 栈为空，输出结束 { // 打印栈顶数据 printf("%d\n", STTop(&s)); // 出栈 STPop(&s); } STDestroy(&s); // 销毁栈s，释放内存空间 return 0; }

代码示例 2.2

// C++实现Stack #include<iostream> #include<assert.h> using namespace std; typedef int STDataType; // typedef重命名，方便修改栈中数据的类型 // Stack类，方法封装到类中，通过访问限定符限制成员的访问 class Stack { public: // public访问限定符，使成员函数可在类外访问 // 初始化方法 void Init(int n = 4) // 缺省参数，若不传参，n默认为4，即栈的默认大小 { // 由于this指针，无需传地址，无需指针接收地址 // 初始化数据空间 _data = (STDataType*)malloc(sizeof(STDataType) * n); // 判断是否成功开辟空间 if (nullptr == _data) { perror("malloc申请空间失败"); return; } // 成功开辟空间，更新空间大小和栈顶 _capacity = n; _top = 0; } // 压栈方法 void Push(STDataType x) { // 判断是否需要扩容 if (_top == _capacity) { // 直接两倍扩容 int newcapacity = _capacity * 2; STDataType* tmp = (STDataType*)realloc(_data, newcapacity * sizeof(STDataType)); // 判断是否扩容成功 if (tmp == NULL) { perror("realloc fail"); return; } // 扩容成功，更新栈空间与空间大小 _data = tmp; _capacity = newcapacity; } // 压栈，更新栈顶 _data[_top++] = x; } // 判断空栈方法 bool Empty() { return _top == 0; } // 出栈方法 void Pop() { // 隐式this指针调用，this->Empty() assert(!Empty()); // 出栈 --_top; } // 获取栈顶元素方法 int Top() { assert(!Empty()); // 返回栈顶元素 return _data[_top - 1]; } // 销毁栈方法 void Destroy() { free(_data); _data = nullptr; _top = _capacity = 0; } private: // 访问限定符限制成员变量为私有，类外无法访问，保护栈中数据 STDataType* _data; size_t _capacity; size_t _top; }; int main() { Stack s; // Stack类的实例化，对象s // 不需要手动传对象地址，交给编译器 // 栈对象的初始化 s.Init(); // 插入数据 s.Push(1); s.Push(2); s.Push(3); s.Push(4); // 输出栈中所有数据，栈为空循环结束 while (!s.Empty()) { // 打印栈顶元素 printf("%d\n", s.Top()); // 出栈 s.Pop(); } // 销毁栈，释放空间 s.Destroy(); return 0; }