C++面向对象之类和对象那些你不知道的细节原理详解_C语言

class SeqStack
{
public:
SeqStack(int size = 10) :_top(-1), _size(size) {
_pstack = new int[size];
}
~SeqStack() {
cout < 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];
}
delete[] _pstack;
_pstack = ptmp;
_size *= 2;
}
};
/**
运行过程
*/
int main() {
SeqStack sq1;
for (int i = 0; i <15; i++) {
sq1.push(rand() % 100);
}
while (!sq1.empty()) {
cout < sq1.pop();
}
return 0;
}

SeqStack& operator=(const SeqStack& src) {
cout <<"operator=" < //防止自赋值
if (this == &src) {
return *this;
}
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;
return *this;
}
SeqStack(const SeqStack& src) {
cout < _pstack = new int[src._size];
for (int i = 0; i <= src._top; i++) {
_pstack[i] = src._pstack[i];
}
_top = src._top;
_size = src._size;
}

#pragma once
class CirQueue
{
public:
CirQueue(int size = 10) {
_pQue = new int[size];
_frOnt= _rear = 0;
_size = size;
}
CirQueue(const CirQueue& src) {
_size = src._size;
_frOnt= src._front;
_rear = src._rear;
_pQue = new int[_size];
for (int i = _front; i != _rear; i = (i + 1) % _size) {
_pQue[i] = src._pQue[i];
}
}
~CirQueue() {
delete[] _pQue;
_pQue = nullptr;
}
CirQueue& operator=(const CirQueue& src) {
if (this == &src) {
return *this;
}
delete[] _pQue;//需要释放掉自身占用的外部资源
_size = src._size;
_frOnt= src._front;
_rear = src._rear;
_pQue = new int[_size];
for (int i = _front; i != _rear; i = (i + 1) % _size) {
_pQue[i++] = src._pQue[i];
}
return *this;
}
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[_size * 2];
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;
}
};

#pragma once
#include
class String
{
public:
String(const char* str = nullptr) {
if (str != nullptr) {
_pChar = new char[strlen(str) + 1];
strcpy(_pChar, str);
}
else {
_pChar = new char[1];
*_pChar = '\0';
}
}
String(const String& str) {
_pChar = new char[strlen(str._pChar)+1];
strcpy(_pChar, str._pChar);
}
~String() {
delete[] _pChar;
_pChar = nullptr;
}
String& operator=(const String& str) {
if (this == &str) {
return *this;
}
delete[] _pChar;//需要释放掉自身占用的外部资源
_pChar = new char[strlen(str._pChar) + 1];
strcpy(_pChar, str._pChar);
return *this;
}
private:
char* _pChar;

};

class Test {
public:
void func() { cout <<"call Test::func" < static void static_func() { cout <<"call Test::static_func" < int ma;
static int mb;
};
int Test::mb=0;
int main() {
Test t1;
Test *t2 = new Test();//在堆上生成对象，并用指针指向
//使用指针调用类成员方法(前面要加类的作用域Test::)
void (Test:: * pfunc)() = &Test::func;
(t1.*pfunc)();
(t2->*pfunc)();
//定义指向static的类成员方法
void(*pfunc1)() = &Test::static_func;
(*pfunc1)();
//使用指针指向类成员变量，前面要加类的作用域Test::
int Test::* p = &Test::ma;
t1.*p = 20;
cout < t2->*p = 30;
cout <*p < int* p1 = &Test::mb;
*p1 = 40;
cout <<*p1 < delete t2;
return 0;
}