C++之类与对象（1）

#include <iostream>
using namespace std;
class Date{
public:
void print(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
cout << _year << " " << _month << " " << _day << endl;
//cout << year << " " << month << " " << day << endl;
}
private:
// 为了区分成员变量，⼀般习惯上成员变量
// 会加⼀个特殊标识，如_ 或者 m开头
int _year; // year_ m_year
int _month;
int _day;

};
int main() {
Date date;
date.print(2024, 7, 18);
return 0;
}

#include<iostream>
using namespace std;
// C++升级struct升级成了类
// 1、类⾥⾯可以定义函数
// 2、struct名称就可以代表类型
// C++兼容C中struct的⽤法
typedef struct ListNodeC
{
struct ListNodeC* next;
int val;
}LTNode;
// 不再需要typedef，ListNodeCPP就可以代表类型
struct ListNodeCPP
{
void Init(int x)
{
next = nullptr;
val = x;
}
ListNodeCPP* next;
int val;
};
int main() {
return 0;
}

• C++一种实现封装的方式，用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访

问，protected和private是一样的，以后继承章节才能体现出他们的区别。

• 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，如果后面没有访问限定符，作用域就到 }即类结束。

• class定义成员没有被访问限定符修饰时默认为private，struct默认为public。

• 一般成员变量都会被限制为private/protected，需要给别人使用的成员函数会放为public。

1.3类域

class MyClass {
public:
    void myFunction();
    int myValue;
};

class MyClass {
public:
    void myFunction();  // 成员函数声明
    int myValue;        // 数据成员声明
};
// 在类体外定义成员函数
void MyClass::myFunction() {
    // 函数实现
    myValue = 10;  // 直接使用类成员
}

MyClass obj;
obj.myFunction();  // 调用成员函数
int value = obj.myValue;  // 访问数据成员

1. 默认对齐方式：每个数据类型的自然对齐方式通常是该类型的大小。例如，`int` 类型通常在4字节边界上对齐，`double` 类型通常在8字节边界上对齐。

2. 结构体和类的对齐：结构体和类的成员按照其类型的自然对齐方式对齐。结构体或类的整体大小也必须符合其最大成员类型的对齐要求。

3. 成员对齐：结构体或类的成员按照声明顺序进行排列，每个成员按其类型的对齐方式放置。

4. 填充（Padding）：为了满足对齐要求，编译器可能会在成员之间插入填充字节。

5. #pragma pack：可以通过`#pragma pack`指令来改变或设置编译器的默认对齐方式。

struct MyStruct {
    char a;    // 1 byte
    int b;     // 4 bytes
    char c;    // 1 byte
};

class MyClass {
public:
    char a;    // 1 byte
    int b;     // 4 bytes
    char c;    // 1 byte
};

// 假设默认对齐方式为4字节

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

上述程序中没有成员变量的B和C类对象的大小是1，为什么没有成员变量还要给1个 字节呢？ 因为如果一个字节都不给，怎么表示对象存在过呢！所以这里给1字节，纯粹是为了占位标识对象存在。

3.this指针

• 在上述代码中Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init和 Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这里就要看到C++给了一个隐含的this指针解决这里的问题

• 编译器编译后，类的成员函数默认都会在形参第一个位置，增加一个当前类类型的指针，叫做this 指针。比如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)

• 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this-

>_year = year;

• C++规定不能在实参和形参的位置显示的写this指针(编译时编译器会处理)，但是可以在函数体内显示使用this指针。

class Date
{
public:
//void Init(Date*const this,int year, int month, int day)
void Init(int year, int month, int day)
{
this->_year = year;
this->_month = month;
this->_day = day;
}
//void Print(Date*const this)
void Print()
{
cout <<this-> _year << "/" << this->_month << "/" <<this-> _day << endl;
}
private:
// 这⾥只是声明，没有开空间
int _year;
int _month;
int _day;
};

实际上建议不加this，这里只是了解一下。

#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;

}