面向对象和程序设计--对象和类-CSDN博客

本文链接：https://blog.csdn.net/2503_91635959/article/details/147198449

#对栈的操作

1）push :进栈（在栈中添加一个元素）

2）pop:退栈（从栈中删除一个元素）

3）LIFO(last in first out) :后进先出->栈的重要性质

##非数据抽象和封装的解决方案

1）定义栈类型

2）用成员buffer->栈中元素（数组）

3）top->标记能添加/删除元素那一端的位置

const int STACK_SIZE = 100;
struct Stack   //定义栈数据类型
{
 int top;
 int buffer[STACK_SIZE];
};

我们现在要对栈数据进行操作

1)基于栈数据

Stack st; //定义一个栈的变量
st.top = -1;   //对st进行初始化

//把数字3放进栈
if(st.top == STACK_SIZE-1) //已满
{
cerr<<"Stack is overflow.\n";
exit(-1);
}
st.top++;
st.buffer[st.top] = 3;

//栈顶元素出栈并将其存入x
int x;
if(st.top == -1)
{
cerr<<"Stack is empty.\n";
exit(-1);
}
x = st.buffer[st,top];
st.top--;

2)基于过程抽象

定义init,push,pop。实现栈的初始化，元素进栈和出栈

void init(Stack &s) //对栈s进行初始化
{
st.top = -1;
}

void push(Stack &s, int i)  //把i放进栈
{
if(s.top == STACK_SIZE-1)   //已经满了
{
cerr<<"Stack is overflow.\n";
exit(-1);
}
else
{
s.top ++;
s.buffer[s.top] = -1;
return ;
}
}

void pop (Stack &s, int &i)  //把栈顶元素取出并放入i
{
if(s.top == -1)
{
cerr<<"Stack is empty.\n";
exit(-1);
}
else
{
i = s.buffer[s.top];
s.top--;
return;
}
}

操作如下：

Stack st; //定义一个栈变量
init(st);  //进行初始化
push(st,3);  //把3放入
int x;
pop(st,x);//栈顶元素出栈并将其存入x

##对象和类

对象和类是面向对象编程中的两个重要概念

类（Class）是一种抽象的数据类型，它定义了一类对象所共有的属性（数据）和行为（方法）。类可以看作是对象的模板或蓝图，用来创建具体的对象。类中的属性表示对象的状态，方法表示对象的行为或功能。

例如，可以定义一个名为"汽车"的类，其中包含属性如车牌号、品牌、颜色等，方法如启动引擎、加速、刹车等。

对象（Object）是类的实例化，是具体存在的数据实体。可以通过类来创建多个对象，并且每个对象都拥有各自独立的状态（属性值）和行为（方法调用）。

使用上述"汽车"类可以创建多个汽车对象，如一辆具体的小汽车、一辆卡车等。每个汽车对象都有自己的车牌号、品牌、颜色等属性，并且可以进行启动引擎、加速、刹车等行为。对象是实际进行操作和交互的实体。

总结来说，类定义了对象的共同特征和行为，而对象是类的实例化，具体存在并可以执行类中定义的操作。对象和类是面

##类

类的定义

定义一个类 = 定义它的属性（成员变量） + 行为（成员函数）

class<类名>
{
<成员描述>;
}; //<-此处有分号

结尾分号不要忘记

###数据成员

在类中定义数据成员时，可以指定其访问权限（public、private、protected等），以确定数据成员的可访问范围。常见的数据成员类型包括整数、浮点数、字符串、布尔值等，甚至可以是其他类的对象。

class Date
{
int year,month,day; //数据成员描述
}；

###成员函数

成员函数是定义在类中的函数，用来操作类的数据成员，实现类的功能和行为。也可以称为方法（Methods）或成员方法（Member Functions）。

成员函数可以访问类中定义的数据成员，也可以调用其他成员函数。通过成员函数，可以实现对类的数据和状态的操作、修改和控制，从而实现类的功能和行为。

举例

class Date
{
public:

void set(int y, int m, int d)  //类中定义的成员函数
{
y = year;
month = m;
day = d;
}

bool is_leap_year()  //类中定义的成员函数
{
return (year%4==0 && year%100!=0)||(year%400==0）；
}

private:
int year,month,day;
};   //此处有分号

还有一种方法可以实现

class Date
{
public:
void set(int y, int m, int d)； //成员函数声明
bool is_leap_year() ；
private:
int year,month,day;
}; 

void Date::set(int y, int m, int d)    //类外定义的成员函数
{
y = year;
month = m;
day = d;
}

bool Date::is_leap_year()  
{
return (year%4==0 && year%100!=0)||(year%400==0）；
}

##类

类（class）是面向对象编程中的一个重要概念，它是一种模板或蓝图，用于创建对象。通过类，可以定义对象的属性（成员变量）和行为（方法）。类可以看作是一种自定义数据类型，它定义了具有相似特征和行为的对象的共同特征。

在许多编程语言中，如Java、Python、C++等，类是面向对象编程的基本构建块之一。通过类的实例化（创建对象），可以在程序中使用该类定义的属性和方法。

在定义类时，通常会包含以下内容：

成员变量（属性）：用于存储对象的状态。
方法（函数）：用于操作对象的行为。
构造函数：用于初始化对象的属性。
访问控制修饰符：用于控制成员变量和方法的访问权限

##构造函数和析构函数

构造函数（Constructor）：构造函数是在创建对象时自动调用的特殊方法，用于初始化对象的属性。在许多编程语言中，构造函数的名称与类名称相同，用来初始化对象的状态。构造函数通常用于执行对象的初始化操作，为对象的属性赋初始值。
析构函数（Destructor）：析构函数是在对象被销毁时自动调用的特殊方法，用于清理对象使用的资源。有些编程语言自动进行内存管理，会在对象不再被引用时自动调用析构函数进行资源释放。析构函数可以用来释放对象占用的资源，如关闭文件、释放内存等操作。

class A{
public:
int n;
char* data = NULL;
A(int n){
this->n = n;
data = (char*)malloc(100);
}
~A()  //析构函数
{
free(data);
}

};

##this指针

this指针在类内部使用，指向当前对象

在C++中，this 指针是一个指向当前对象的指针，它可以在类的成员函数中使用，用来访问当前对象的成员变量和成员函数。通过 this 指针，可以解决同名变量的歧义问题，也可以在类的方法中返回对当前对象的引用。

以下是一个使用 this 指针的简单示例：

#include <iostream>

class Person {
private:
    std::string name;

public:
    Person(const std::string& name) {
        // 使用this指针访问成员变量
        this->name = name;
    }

    void printName() {
        // 使用this指针访问成员函数
        std::cout << "My name is: " << this->getName() << std::endl;
    }

    std::string getName() {
        // 在成员函数中返回对当前对象的引用
        return this->name;
    }
};

int main() {
    Person person("Alice");
    person.printName();

    return 0;
}

在上面的示例中，构造函数中使用 this 指针来访问成员变量 name，以区分参数 name 和成员变量 name。在 printName() 方法中，使用 this 指针调用 getName() 方法来获取当前对象的名字。

##关于为什么要使用this指针

在很多编程语言中，this指针（或者关键字）通常用来表示当前对象的引用。在面向对象编程中，使用this指针有以下几个作用：