廊坊开发区规划建设局网站,我想建一个网站怎么建,黑帽seo,杭州市做外贸网站的公司文章目录 一、C的struct和C的类的区别二、关于OOP三、举例#xff1a;一个商品类CGoods四、构造函数和析构函数1、定义一个顺序栈2、用构造和析构代替s.init(5);和s.release();3、在不同内存区域构造对象4、深拷贝和浅拷贝5、构造函数和深拷贝的简单应用6、构造函数的初始化列… 文章目录 一、C的struct和C的类的区别二、关于OOP三、举例一个商品类CGoods四、构造函数和析构函数1、定义一个顺序栈2、用构造和析构代替s.init(5);和s.release();3、在不同内存区域构造对象4、深拷贝和浅拷贝5、构造函数和深拷贝的简单应用6、构造函数的初始化列表 五、类的各种成员变量和成员方法1、普通成员变量、静态成员变量2、普通成员方法、静态成员方法、常成员方法 六、指向类成员成员变量和成员方法的指针 一、C的struct和C的类的区别
以下表格由DeepSeek-R1生成
特性C 的 structC 的 structC 的 class默认访问权限无仅数据publicprivate成员函数不支持支持支持继承/多态不支持支持支持构造/析构函数不支持支持支持模板不支持支持支持设计用途纯数据聚合简单数据方法封装复杂对象行为
实际开发中C 的 struct 和 class 仅默认权限不同但习惯上用 struct 表示数据为主的结构class 表示具有复杂行为的对象。
在C中 各种各样的函数的定义、struct在C中 实体(属性、行为) - ADT(abstract data type) 对象 -(实例化) 类(属性-成员变量行为-成员方法)
二、关于OOP
Object Oriented Programming面向对象程序设计OOP语言的四大特性抽象、封装/隐藏、继承、多态类中的访问限定符由DeepSeek-R1生成
基类成员访问限定符类内部访问继承方式派生类中基类成员的访问权限外部代码访问友元访问public✔public 继承public✔✔protected 继承protected✖✔private 继承private✖✔protected✔public 继承protected✖✔protected 继承protected✖✔private 继承private✖✔private✔任何继承方式不可访问✖✔
三、举例一个商品类CGoods
#include iostream
using namespace std;const int NAME_LEN 20;class CGoods {
public: // 给外部提供公有的成员方法来访问私有的属性// 商品数据初始化void init(const char *name, double price, int amount);// 打印商品信息void show();// 给成员变量提供getXXX或setXXX的方法注意类内部实现的方法自动处理成inline内联函数void setName(const char *name) { strcpy_s(_name, sizeof(_name), name); }void setPrice(double price) { _price price; }void setAmount(int amount) { _amount amount; }const char *getName() { return _name; }double getPrice() { return _price; }int getAmount() { return _amount; }
private:char _name[NAME_LEN];double _price;int _amount;
};void CGoods::init(const char *name, double price, int amount) {strcpy_s(_name, sizeof(_name), name);_price price;_amount amount;
}void CGoods::show() {cout name: _name endl;cout price: _price endl;cout amount: _amount endl;
}int main() {CGoods good1;good1.init(面包, 10.0, 200); good1.show();good1.setPrice(20.5); good1.setAmount(100); good1.show();CGoods good2;good2.init(空调, 10000.0, 50);good2.show();return 0;
}注意
类可以定义无数个对象每一个对象都有自己的成员变量但是它们共享一套成员方法。类内部实现的方法自动处理成inline内联函数外部则不会。对象的内存大小与成员变量有关。VS2022下可以通过cl C面向对象.cpp /dlreportSingleClassLayoutCGoods查看占用内存大小。init(namepriceamount)怎么知道处理哪个对象的信息把信息初始化给哪一个对象的呢? 类的成员方法一经编译所有的方法参数都会加一个this指针接收调用该方法的对象的地址。 void init(CGoods *this, const char *name, double price, double amount);void CGoods::init(CGoods *this, const char *name, double price, int amount) {strcpy_s(this-_name, sizeof(this-_name), name);this-_price price;this-_amount amount;}init(good1, 面包, 10.0, 200);四、构造函数和析构函数
1、定义一个顺序栈
#include iostream
using namespace std;const int NAME_LEN 20;class SeqStack {
public: void init(int size 10) {_pstack new int[size];_top -1;_size size;}void release() {delete[]_pstack;_pstack nullptr;}void push(int val) {if (full()) {resize();}_pstack[_top] val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top -1; }bool full() { return _top _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp new int[_size * 2];for (int i 0; i _size; i) {ptmp[i] _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack ptmp;_size * 2;}
};int main() {SeqStack s;s.init(5); for (int i 0; i 15; i) {s.push(rand() % 100);}while (!s.empty()) {cout s.top() ;s.pop();}s.release();return 0;
}2、用构造和析构代替s.init(5);和s.release();
#include iostream
using namespace std;const int NAME_LEN 20;class SeqStack {
public: SeqStack(int size 10) { // 构造函数可带参数可以重载_pstack new int[size];_top -1;_size size;}~SeqStack() { // 不带参数只能有一个delete[]_pstack;_pstack nullptr;}void push(int val) {if (full()) {resize();}_pstack[_top] val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top -1; }bool full() { return _top _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp new int[_size * 2];for (int i 0; i _size; i) {ptmp[i] _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack ptmp;_size * 2;}
};int main() {//1.开辟内存 2.调用构造函数SeqStack s(5);//s.init(5); // 对象成员变量的初始化for (int i 0; i 15; i) {s.push(rand() % 100);}while (!s.empty()) {cout s.top() ;s.pop();}//s.release(); // 释放对象成员变量占用的外部堆内存(外部资源)return 0;
}3、在不同内存区域构造对象
#include iostream
using namespace std;const int NAME_LEN 20;class SeqStack {
public: SeqStack(int size 10) {cout this SeqStack endl;_pstack new int[size];_top -1;_size size;}~SeqStack() {cout this ~SeqStack endl;delete[]_pstack;_pstack nullptr;}void push(int val) {if (full()) {resize();}_pstack[_top] val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top -1; }bool full() { return _top _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp new int[_size * 2];for (int i 0; i _size; i) {ptmp[i] _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack ptmp;_size * 2;}
};/*
.data
heap
stack
*/
SeqStack s0; //.dataint main() {cout heap上对象构造 endl;SeqStack* ps new SeqStack(60); // heap malloc内存开辟SeqStack对象构造ps-push(70);ps-push(80);ps-pop();cout ps-top() endl;delete ps; // 先调用ps-~SeqStack()然后free(ps)cout stack上对象构造 endl;SeqStack s(5); //stackfor (int i 0; i 15; i) {s.push(rand() % 100);}while (!s.empty()) {cout s.top() ;s.pop();}cout endl;return 0;
}打印结果如下
00007FF7FB3914C0 SeqStack
heap上对象构造
0000026D43E94EF0 SeqStack
70
0000026D43E94EF0 ~SeqStack
stack上对象构造
000000F8EF6FF9D8 SeqStack
61 27 81 45 5 64 62 58 78 24 69 0 34 67 41
000000F8EF6FF9D8 ~SeqStack
00007FF7FB3914C0 ~SeqStack4、深拷贝和浅拷贝 SeqStack s; // 没有提供任何构造函数的时候会为你生成默认构造函数SeqStack s1(10);SeqStack s2 s1; // #1 默认拷贝构造函数 -》做直接内存数据拷贝//Seqstack s3(s1);// #2 同1上述默认构造函数导致出现浅拷贝的问题浅拷贝一般包括以下几种问题 多个对象共享同一资源 如果多个对象的指针成员指向同一块内存修改其中一个对象会影响其他对象。 重复释放资源 当多个对象的指针指向同一块内存时析构函数可能会多次释放同一块内存导致程序崩溃。 内存泄漏 如果资源被浅拷贝后原始对象的资源没有被正确释放会导致内存泄漏。
默认拷贝构造函数浅拷贝 SeqStack(const SeqStack src) {_pstack src._pstack;_top src._top;_size src._size;}深拷贝 SeqStack(const SeqStack src) {_pstack new int[src._size];for (int i 0; i src._top; i) {_pstack[i] src._pstack[i];}_top src._top;_size src._size;}如果对两个已经存在的对象进行赋值操作也会出现浅拷贝问题
int main() {cout 开始构造s endl;SeqStack s; // 没有提供任何构造函数的时候会为你生成默认构造函数cout 开始构造s1 endl;SeqStack s1(10);cout 开始构造s2 endl;SeqStack s2 s1; // #1 默认拷贝构造函数 -》做直接内存数据拷贝//Seqstack s3(s1);// #2 同1s2 s1;return 0;
}s2 s1; // 默认的赋值函数 》做直接的内存拷贝 修改如下 // s2.operator(s1) // void operator(const SeqStack src)
#include iostream
using namespace std;const int NAME_LEN 20;class SeqStack {
public: SeqStack(int size 10) {cout this SeqStack endl;_pstack new int[size];_top -1;_size size;}// 自定义拷贝构造函数SeqStack(const SeqStack src) { cout this const SeqStack src endl;_pstack new int[src._size];for (int i 0; i src._top; i) {_pstack[i] src._pstack[i];}_top src._top;_size src._size;}// 赋值重载函数void operator(const SeqStack src) {cout this operator endl;// 防止自赋值if (this src) {return;}// 需要先释放当前对象占用的外部资源delete[]_pstack;_pstack new int[src._size];for (int i 0; i src._top; i) {_pstack[i] src._pstack[i];}_top src._top;_size src._size;}~SeqStack() {cout this ~SeqStack endl;delete[]_pstack;_pstack nullptr;}void push(int val) {if (full()) {resize();}_pstack[_top] val;}void pop() {if (empty()) {return;}--_top;}int top() {return _pstack[_top];}bool empty() { return _top -1; }bool full() { return _top _size - 1; }private:int *_pstack;int _top;int _size;void resize() {int* ptmp new int[_size * 2];for (int i 0; i _size; i) {ptmp[i] _pstack[i];} // memcpy(ptmp, _pstack, sizeof(int)*size);或realloc可能产生深拷贝浅拷贝的问题delete[]_pstack;_pstack ptmp;_size * 2;}
};int main() {cout 开始构造s endl;SeqStack s; // 没有提供任何构造函数的时候会为你生成默认构造函数cout 开始构造s1 endl;SeqStack s1(10);cout 开始构造s2 endl;SeqStack s2 s1; // #1 默认拷贝构造函数 -》做直接内存数据拷贝//Seqstack s3(s1);// #2 同1s2 s1;return 0;
}
打印结果
开始构造s
0000003B8E14F6C8 SeqStack
开始构造s1
0000003B8E14F6F8 SeqStack
开始构造s2
0000003B8E14F728 const SeqStack src
0000003B8E14F728 operator
0000003B8E14F728 ~SeqStack
0000003B8E14F6F8 ~SeqStack
0000003B8E14F6C8 ~SeqStack5、构造函数和深拷贝的简单应用
字符串String
#include iostream
using namespace std;class String {
public: String(const char* str nullptr) { // 普通构造函数if (str ! nullptr) {m_data new char[strlen(str) 1];strcpy_s(m_data, strlen(str) 1, str);}else {m_data new char[1];*m_data \0;}}String(const String other) { // 拷贝构造函数m_data new char[strlen(other.m_data) 1];strcpy_s(m_data, strlen(other.m_data) 1, other.m_data);}~String() {delete[]m_data;m_data nullptr;}String operator(const String other) { // 返回值不是void而是当前类型的引用是为了连续赋值if (this other) {return *this;}delete[]m_data;m_data new char[strlen(other.m_data) 1];strcpy_s(m_data, strlen(other.m_data) 1, other.m_data);return *this;}private:char* m_data;
};int main() {// 调用带const char*参数的构造函数String str1;String str2(hello);String str3 world;// 调用拷贝构造函数String str4 str3;String str5(str4);// 调用赋值重载函数str1 str2;str3 str1 str2; // 连续赋值return 0;
}
循环队列Queue
#include iostream
using namespace std;class Queue {
public: Queue(int size 20) {_pQue new int[size];_front _rear 0;_size size;}Queue(const Queue src) {_front src._front;_rear src._rear;_size src._size;_pQue new int[_size];for (int i _front; i ! _rear; i (i 1) % _size) {_pQue[i] src._pQue[i];}}Queue operator(const Queue src) {if (this src) {return *this;}delete[]_pQue;_front src._front;_rear src._rear;_size src._size;_pQue new int[_size];for (int i _front; i ! _rear; i (i 1) % _size) {_pQue[i] src._pQue[i];}return *this;}~Queue() {delete[]_pQue;_pQue nullptr;}void push(int val) {// 入队操作if (full()) {resize();}_pQue[_rear] val;_rear (_rear 1) % _size;}void pop() { // 出队操作if (empty()) {return;}_front (_front 1) % _size;}int front() {return _pQue[_front];}bool full() {return (_rear 1) % _size _front;}bool empty() {return _front _rear;}private:int* _pQue; // 申请队列的数组空间int _front; // 指示队头的位置int _rear; // 指示队尾的位置int _size; // 队列扩容的总大小void resize() {int* ptmp new int[2 * _size];int index 0;for (int i _front; i ! _rear; i (i 1) % _size) {ptmp[index] _pQue[i];}delete[]_pQue;_pQue ptmp;_front 0;_rear index;_size * 2;}
};int main() {Queue q;for (int i 0; i 20; i) {q.push(rand() % 100);}while (!q.empty()) {cout q.front() ;q.pop();}cout endl;Queue q1 q;q1 q;return 0;
}6、构造函数的初始化列表
#include iostream
using namespace std;class CDate {
public:CDate(int y, int m, int d) { //自定义的构造函数_year y;_month m;_day d;}void show() {cout _year / _month / _day endl;}private:int _year;int _month;int _day; };/*
构造函数的初始化列表: 可以指定当前对象成员变量的初始化方式
CDate信息 CGoods商品信息的一部分 a part of ... 组合的关系
*/
class CGoods {
public: // CDate没有合适的构造函数可用因此在这里使用初始化列表CGoods(const char *n, int a, double p, int y, int m, int d): _date(y, m, d), _amount(a) // 相当于int _amount a;直接进行初始化// 避免了先定义int _amount; _amount a;需要调用默认构造函数// 而CDate因为定义了自定义的构造函数不会调用默认构造函数, _price(p) // #1 构造函数的初始化列表{// #2 当前类类型构造函数体strcpy_s(_name, 20, n);}void show() {cout name: _name endl;cout amount: _amount endl;cout price: _price endl;_date.show();}private:char _name[20];int _amount;double _price;CDate _date; // 成员对象 1.分配内存 2.调用构造函数
};int main() {CGoods good(商品, 100, 35.0, 2025, 1, 27);good.show();return 0;
}注意成员变量的初始化和它们定义的顺序有关和构造函数初始化列表中出现的先后顺序无关!
#include iostream
using namespace std;class Test {
public: Test(int m 10):mb(m), ma(mb) {}void show() {cout ma: ma mb: mb endl;}private:int ma;int mb;
};int main() {Test t; t.show(); // ma: -858993460 mb: 10return 0;
}Windows下会将未初始化的内存填充为特定的值0xCCCCCCCC十进制为-858993460先初始化ma而此时mb未初始化其值-858993460因此ma: -858993460而mb: 10。
五、类的各种成员变量和成员方法
1、普通成员变量、静态成员变量
2、普通成员方法、静态成员方法、常成员方法
普通的成员方法 编译器会添加一个this形参变量 1.属于类的作用域 2.调用该方法时需要依赖一个对象常对象是无法调用的 实参:const CGoods* -》CGoods *this 3.可以任意访问对象的私有成员 protected继承 public privatestatic静态成员方法 不会生成this形参 1.属于类的作用域 2.用类名作用域来调用方法 3.可以任意访问对象的私有成员仅限于不依赖对象的成员只能调用其它的static静态成员const常成员方法 const CGoods *this 1.属于类的作用域 2.调用依赖一个对象普通对象或者常对象都可以 3.可以任意访问对象的私有成员但是只能读而不能写只要是只读操作的成员方法一律实现成const常成员方法
#include iostream
using namespace std;const int NAME_LEN 20;class CGoods {
public:CGoods(const char* name, double price, int amount);void show();void show() const;static void showCount();private:char _name[NAME_LEN];double _price;int _amount;static int _count; // 声明 用来记录商品对象的总数量不属于对象而属于类级别的
};// static成员变量一定要在类外进行定义并且初始化
int CGoods::_count 0; CGoods::CGoods(const char* name, double price, int amount) {strcpy_s(_name, sizeof(_name), name);_price price;_amount amount;_count; // 记录所有产生的新对象的数量
}// 普通成员方法 CGoods *this
void CGoods::show() {cout name: _name endl;cout price: _price endl;cout amount: _amount endl;
}// 常成员方法 const CGoods *this
void CGoods::show() const {cout name: _name endl;cout price: _price endl;cout amount: _amount endl;
}// 静态成员方法 没有this指针
void CGoods::showCount() {cout 所有商品数量: _count endl;
}int main() {CGoods good1(面包, 10.0, 200);good1.show();CGoods good2(空调, 100.0, 50);good2.show();CGoods::showCount();const CGoods good3(非卖品, 10000.0, 1);good3.show(); //CGoods::show(good3) const CGoods* - CGoods*不可以return 0;
}六、指向类成员成员变量和成员方法的指针
指向普通成员变量的指针依赖于对象的调用指向静态成员变量的指针不依赖。 指向普通成员方法的函数指针同样依赖于对象的调用指向静态成员方法的指针不依赖。
#include iostream
using namespace std;class Test {
public:void func() { cout call Test::func endl; }static void static_func() { cout Test::static func endl; }int ma;static int mb;
};int Test::mb;int main() {Test t1; Test *t2 new Test();// 指向成员变量的指针// int a10; int *pa; *p30;int Test::*p Test::ma;t1.*p 20;cout t1.*p endl;t2-*p 30; cout t2-*p endl; // 指向静态成员变量的指针int *p1 Test::mb;*p1 40;cout *p1 endl;// 指向成员方法的指针void (Test::*pfunc)() Test::func; (t1.*pfunc)();(t2-*pfunc)();// 定义函数指针指向类的静态成员方法void(*pfunc1)() Test::static_func;(*pfunc1)();delete t2;return 0;
}打印结果如下
20
30
40
call Test::func
call Test::func
Test::static func
