博客介绍了C语言使用struct进行面向对象编程的三种方法，包括基础版、改进版和使用C++方式。同时详细阐述了C++类与对象的相关知识，如类定义、对象创建、成员访问、成员函数、访问修饰符、构造与析构函数等内容。
文章目录
C语言-struct 面向对象
采用C语言 使用struct 进行封装
方法1:基础版
缺点，这种方法将成员变量和方法进行了分离。
#include <stdio.h>
typedef struct arr
{
int data[100]; //成员对象
int tail;
}ARR;
//数据操作方法
void init(ARR *arr);
void addtail(ARR *arr, int data);
void show(ARR *arr);
void init(ARR *arr)
{
arr->tail = 0;
}
void addtail(ARR *arr, int data)
{
arr->data[arr->tail++] = data;
}
void show(ARR *arr)
{
int i;
for( i=0;i<arr->tail; i++)
printf("%d, ", arr->data[i]);
printf("\n");
}
int main(int argc, const char *argv[])
{
ARR arr;
init(&arr);
int n = 10;
while(n--)
addtail(&arr, n);
show(&arr);
return 0;
}
方法2:改进版
使用函数指针 将实现方法进行封装
typedef struct arr{
int data[100];
int tail;
void (*addtail)(struct arr *arr, int data);
void (*show)(struct arr *arr);
}ARR;
void init(ARR *arr);
static void addtail(ARR *arr, int data);
static void show(ARR *arr);
void init(ARR *arr)
{
arr->tail = 0;
arr->addtail = addtail;//函数入口注册
arr->show = show;
}
static void addtail(ARR *arr, int data)
{
arr->data[arr->tail++] = data;
}
static void show(ARR *arr)
{
int i;
for( i=0;i<arr->tail; i++)
printf("%d, ", arr->data[i]);
printf("\n");
}
int main(int argc, const char *argv[])
{
ARR arr;
init(&arr);
int n = 10;
while(n--)
arr.addtail(&arr, n);
arr.show(&arr);
return 0;
}
打印效果：
9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
方法3：使用C++方式
#include <stdio.h>
class ARR
{
public:
ARR()
{
tail = 0;
}
void addtail(int data);
void show(void);
private:
int data[100];
int tail;
};
void ARR::addtail(int data)
{
this->data[tail++] = data;
}
void ARR::show(void)
{
int i = 0;
for(;i<tail; i++)
printf("%d, ", data[i]);
printf("\n");
}
int main(int argc, const char *argv[])
{
ARR arr;
arr.addtail(1);
arr.addtail(2);
arr.addtail(3);
arr.addtail(4);
arr.show();
return 0;
}
C++ 类 & 对象
C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。
类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。
C++ 类定义
定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。
类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。
例如，使用关键字 class 定义 Box 数据类型，如下所示：
class Box
{
public:
double length; // 盒子的长度
double breadth; // 盒子的宽度
double height; // 盒子的高度
};
定义 C++ 对象
类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象：
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
对象 Box1 和 Box2 都有它们各自的数据成员。
访问数据成员
类的对象的公共数据成员可以使用直接成员访问运算符 (.) 来访问。
#include <iostream>
using namespace std;
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
};
int main( )
{
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
double volume = 0.0; // 用于存储体积
// box 1 详述
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 详述
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// box 1 的体积
volume = Box1.height * Box1.length * Box1.breadth;
cout << "Box1 的体积：" << volume <<endl;
// box 2 的体积
volume = Box2.height * Box2.length * Box2.breadth;
cout << "Box2 的体积：" << volume <<endl;
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Box1 的体积：210
Box2 的体积：1560
- 需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。我们将在后续的教程中学习如何访问私有成员和受保护的成员。
C++ 类成员函数
C++ 类成员函数
类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
double getVolume(void)
{
return length * breadth * height;
}
};
也可以在类的外部使用范围解析运算符 :: 定义该函数，如下所示：
double Box::getVolume(void)
{
return length * breadth * height;
}
C++ 类访问修饰符
-
类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。
-
数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。
class Base { public: // 公有成员 protected: // 受保护成员 private: // 私有成员 };
| 修饰符 | 作用范围 |
|---|---|
| 公有（public）成员 | 公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值 |
| 私有（private）成员 | 私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。默认情况下，类的所有成员都是私有的 |
| 保护（protected）成员 | 保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。 |
C++ 类构造函数 & 析构函数
C++ 类构造函数 & 析构函数
类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
C++ 拷贝构造函数
C++ 拷贝构造函数
拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
C++ 友元函数
C++ 友元函数
友元函数可以访问类的 private 和 protected 成员。
-
类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。
-
友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。
-
如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend，如下所示：
class Box { double width; public: double length; friend void printWidth( Box box ); void setWidth( double wid ); };
C++ 内联函数
C++ 内联函数
通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
-
C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。
-
对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。
-
如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。
-
在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。
#include <iostream> using namespace std; inline int Max(int x, int y) { return (x > y)? x : y; } // 程序的主函数 int main( ) { cout << "Max (20,10): " << Max(20,10) << endl; cout << "Max (0,200): " << Max(0,200) << endl; cout << "Max (100,1010): " << Max(100,1010) << endl; return 0; }
当上面的代码被编译和执行时，它会产生下列结果：
Max (20,10): 20
Max (0,200): 200
Max (100,1010): 1010
C++ 中的 this 指针
每个对象都有一个特殊的指针 this，它指向对象本身。
-
在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。
-
友元函数没有 this 指针，因为友元不是类的成员。只有成员函数才有 this 指针。
#include <iostream> using namespace std; class Box { public: // 构造函数定义 Box(double l=2.0, double b=2.0, double h=2.0) { cout <<"Constructor called." << endl; length = l; breadth = b; height = h; } double Volume() { return length * breadth * height; } int compare(Box box) { return this->Volume() > box.Volume(); } private: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box }; int main(void) { Box Box1(3.3, 1.2, 1.5); // Declare box1 Box Box2(8.5, 6.0, 2.0); // Declare box2 if(Box1.compare(Box2)) { cout << "Box2 is smaller than Box1" <<endl; } else { cout << "Box2 is equal to or larger than Box1" <<endl; } return 0; }
当上面的代码被编译和执行时，它会产生下列结果：
Constructor called.
Constructor called.
Box2 is equal to or larger than Box1
C++ 中指向类的指针
C++ 中指向类的指针
指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
C++ 类的静态成员
C++ 类的静态成员
类的数据成员和函数成员都可以被声明为静态的。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
