c++大作业画sin曲线

重庆科技学院

《Visual C++程序设计》大作业

专业班级： 应数12级2班 学 号： 姓 名： 成 绩：

《Visual C++程序设计》

一、公共部分

1.请详细地论述面向对象的封装性和继承性。

封装性：

封装（Encapsulation）就是把对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。封装有两个含义：一是把对象的全部属性和行为结合在一起，形成一个不可分割的独立单位，对象的属性值（除了公有的属性值）只能由这个对象的行为来读取和修改；二是尽可能隐蔽对象的内部细节，对外形成一道屏障，与外部的联系只能通过外部接口实现。

封装的信息隐蔽作用反映了事物的相对独立性，可以只关心它对外所提供的接口，即能做什么，而不注意其内部细节，即怎么提供这些服务。例如，用陶瓷封装起来的一块集成电路芯片，其内部电路是不可见的，而且使用者也不关心它的内部结构，只关心芯片引脚的个数、引脚的电气参数及引脚提供的功能，利用这些引脚，使用者将各种不同的芯片连接起来，就能组装成具有一定功能的模块。

封装的结果使对象以外的部分不能随意存取对象的内部属性，从而有效地避免了外部错误对它的影响，大大减小了查错和排错的难度。另一方面，当对象内部进行修改时，由于它只通过少量的外部接口对外提供服务，因此同样减小了内部的修改对外部的影响。同时，如果一味地强调封装，则对象的任何属性都不允许外部直接存取，要增加许多没有其他意义，只负责读或写的行为。这为编程工作增加了负担，增加了运行开销，并且使得程序显得臃肿。为了避免这一点，在语言的具体实现过程中应使对象有不同程度的可见性，进而与客观世界的具体情况相符合。

封装机制将对象的使用者与设计者分开，使用者不必知道对象行为实现的细节，只需要用设计者提供的外部接口让对象去做。封装的结果实际上隐蔽了复杂性，并提供了代码重用性，从而降低了软件开发的难度。

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。

继承性：

客观事物既有共性，也有特性。如果只考虑事物的共性，而不考虑事物的特性，就不能反映出客观世界中事物之间的层次关系，不能完整地、正确地对客观世界进行抽象描述。运用抽象的原则就是舍弃对象的特性，提取其共性，从而得到适合一个对象集的类。如果在这个类的基础上，再考虑抽象过程中各对象被舍弃的那部分特性，则可形成一个新的类，这个类具有前一个类的全部特征，是前一个类的子集，形成一种层次结构，即继承结构。

- 1 -

《Visual C++程序设计》

继承（Inheritance）是一种联结类与类的层次模型。继承性是指特殊类的对象拥有其一般类的属性和行为。继承意味着“自动地拥有”，即特殊类中不必重新定义已在一般类中定义过的属性和行为，而它却自动地、隐含地拥有其一般类的属性与行为。继承允许和鼓励类的重用，提供了一种明确表述共性的方法。一个特殊类既有自己新定义的属性和行为，又有继承下来的属性和行为。尽管继承下来的属性和行为是隐式的，但无论在概念上还是在实际效果上，都是这个类的属性和行为。当这个特殊类又被它更下层的特殊类继承时，它继承来的和自己定义的属性和行为又被下一层的特殊类继承下去。因此，继承是传递的，体现了大自然中特殊与一般的关系。

在软件开发过程中，继承性实现了软件模块的可重用性、独立性，缩短了开发周期，提高了软件开发的效率，同时使软件易于维护和修改。这是因为要修改或增加某一属性或行为，只需在相应的类中进行改动，而它派生的所有类都自动地、隐含地作了相应的改动。

由此可见，继承是对客观世界的直接反映，通过类的继承，能够实现对问题的深入抽象描述，反映出人类认识问题的发展过程。

2.请结合例程分别详细的论述什么是面向对象的静态多态和运行时多态。

多态性是面向对象程序设计的重要特性之一，它与封装性和继承性面向对象程序设计的三大特性。所谓多态性，是指不同类型的对象接受相同的消息时产生不同的行为。这里的消息主要是指对类的成员函数的调用，而不同的行为是指成员函数的不同实现。

在c++中，多态性可分为两种：编译时的多态性（静态多态）和运行时的多态性。

运行时多态：

运行时的多态性是通过虚函数(virtual)来实现的，它指在程序执行之前，根据函数和参数还无法确定应该调用哪一个函数，必须在程序的执行过程中，根据具体的执行情况动态地确定。 #include class CShape {

public:

virtual float area() //将area定义成虚函数 { return 0.0; } };

class CTtriangle: public CShape

{

public:

CTtriangle(float h,float w)

{ H=h; W=w; } Float area()

{ return(float)(H*W*0.5); } private:

Float H,W; };

Class CCircle:public CShape

- 2 -

《Visual C++程序设计》

{

public:

CCircle(float r) { R=r; } float area()

{ return(float)(3.14159265*R*R); } private:

Floa R; };

int main() {

CShape*s[2];

s[0]=new CTriangle(3,4); cout<area()<

cout<area()<

程序运行结果如下： 6

78.5398

代码中，虚函数area是通过在基类的area函数前面加上virtual关键字来实现的。程序中*s[2]是定义的基类CShape指针，语句“s[0]=new CTriangle(3,4);”是将s[0]指向派生类CTriangle，因而“s[0]->area()”实际上是调用CTriangle类的area成员函数，结果是6；同样可以分析s[1]->area()的结果。

从这个例子可以看出，正是通过虚函数，达到了用基类指针访问派生类对象成员函数的目的，从而使一个函数具有多种不同的版本，这一点与重载函数相似，只不过虚函数的不同版本是在该基类的派生类中重新定义的。这样，只要声明了基类指针就可以使不同的派生类对象产生不同的函数调用，实现了程序的运行时多态。

需要说明的是：

（1）虚函数在重新定义时，参数的个数和类型必须和基类中的虚函数完全匹配，这一点和函数重载完全不同。

（2）只有通过基类指针才能实现虚函数的多态性，若虚函数的调用是通过普通方式来进行的，则不能实现其多态性。例如： CShape ss;

cout<

（3）如果不使用new来创建相应的派生类对象指针，也可以通过使用&运算符来获取对象的地址。例如：

- 3 -

《Visual C++程序设计》

void main() {

CShape*p1,*p2; CTriangle tri(3,4); CCircle cir(5); p1=&tri;p2=○

cout<area()<area()<

（4）虚函数必须是类的一个成员函数，不能是友元函数，也不能是静态的成员函数。

（5）可以把析构函数定义为虚函数，但不能将构造函数定义为虚函数。通常在释放基类中及其派生类中动态申请存储空间时，也要把析构函数定义为虚函数，以便实现撤销对象时的多态性。

静态多态：

编译时的多态性态则是通过函数或运算符的重载来实现的，下面举两个例子： 1）函数模板

template

T max(const T& lsh, const T& rhs) {

return (lsh > rhs) ? lsh : rhs; }

返回两个任意类型对象的最大值，前提是该类型能够使用>运算符进行比较，并且返回值是BOOL类型。

使用：

int a = 3; int b = 4;

cout << max(a, b) << endl; float c = 2.4; float d = 1.2; cout << max(c, d) << endl; 输出结果为： 4 2.4

这种绑定发生在编译期，这是由于模板的实例化是发生在编译期的，即在编译时编译器发现你调用max(a, b)时就自动生成一个函数 int max(const int& lsh, const int& rhs) {

return (lsh > rhs) ? lsh : rhs; }

2）函数重载

- 4 -

《Visual C++程序设计》

int max (int a, int b) {

return (a > b) ? a : b; }

int max (int a, int b, int c) {

return max(max(a, b), c); }

以上两个函数名称一样，参数类型或个数不完全相同，返回值一样。

使用：

int a = 3, b = 4, c = 5;

cout << max(a, b) << endl; cout << max(a, b, c) << endl; 输出结果为： 4 5

确定函数的过程也发生在编译器，当你使用max(a, b)，编译器发现只有两个参数，那么就调用只有两个参数的函数版本，当使用max(a, b, c)时，编译器则使用有3个参数的版本。 通过上面的两个例子，你还可以使用更为方便的函数重载： template

T max(const T& lsh, const T& rhs) {

return (lsh > rhs) ? lsh : rhs; }

template

T max(const T& a, const T& b, const T& c) {

return max(max(a, b), c); }

使用：

float a = 3.6, b = 1.2, c = 7.8; cout << max(a, b, c) << endl; 输出结果为： 7.8

通过参数个数和类型，编译器自动生成和调用对应得函数版本。

- 5 -

《Visual C++程序设计》

3.详细描述你所理解的MFC的文档视图架构。

应用程序的大部分代码都会被添加在文档和视图这两类中。文档和视图紧密相连，是用户和文档之间的交互接口。用户通过文档视图结构可实现数据的传输、编辑、读取和保存等。但文档、视图以及和应用程序框架的相关部分之间还包含了一系列非常复杂的相互作用。拆分窗口和一档多视是文档和视图相互作用的典型实例。

1.文档视图结构概述

文档即应用程序数据的基本元素的集合，是构成应用程序所使用的数据单元，提供数据管理和维护的手段。

视图即在文档和用户之间其中介作用，是数据的用户窗口，提供文档数据的显示功能，并为用户提供了数据交互操作的界面。

MFC提供了两类文档应用程序：只有一个窗口的单文档界面（SDI）及同时可以操作多个文档的多文档界面（MDI）。

2.文档与视图的相互作用

MFC应用程序用一种编程式使程序中数据与它的显示形式和用户交互分离开来，这种模式就是“文档视图结构”，文档视图结构能方便地实现文档和视图的相互作用。一旦在用MFC AppWizard (exe)创建SDI/MDI的第1步中选中了Document/View architecture support(文档/视图体系结构支持)复选框，就可使用CView::GetDocument、CDocument::UpdateAllViews、CView::OnUpdate、

CView::OnInitialUpdate及CDocument::OnNewDocument 5个文档和视图相互作用的重要成员函数。

3.文档视图结构的内在机制

A.文档保留了该文档的视图列表，一个文档至少有一个相关联的视图，而一个视图只能与一个文档关联。

B.视图保留了指向其对应的指针，该指针包含在视图所在框架之中。

C.框架保留了指向其当前活动视图的指针。 MFC提供了文档/视图模型以实现数据和现实的分离。文档类（Dcument）用来维护、管理数据，包括数据的读取、存储与修改；视图类（View）用来接收显示数据，将这些数据交给文档类来处理。 在文档/视图结构中，MFC文档对象将数据读入或写入永久存储区，并提供数据驻留位置的接口。而一个视图对象可以管理数据显示，包括在窗口中显示数据。编辑数据等。MFC可以利用文档/视图结构使用一个单独的视图对象表示每个数据视图，还可以使用文档对象同时更新所有试图。MFC文档/视图将数据结构的存储与维护同其是分开的，图4显示了文档与视图的关系。

- 6 -

《Visual C++程序设计》

视图 文档 当前可见的文档视图 图1 文档与视图的关系

文档/视图结构类的各自主要作用：

1）文档用于管理应用程序的数据。

2) 视图的主要作用是以图形方式显示文档数据，以及接收用户的输入并将其解释为对文档的操作。

3）MFC框架使用框架窗口来包含视图，框架窗口提供了用于环绕视图的可见框架（菜单、最小化和最大化窗口等），使用窗口框架类管理框架，使用视图类管理框架中的视图，用户与文档之间的交互操作发生在视图的客户区内，而不是框架窗口的客户区内；

4）框架使用了两个文档模板类用于管理创建文档及关联的视图和框架窗口的复杂过程，由应用程序对象创建文档模板，由文件模板创建文档和框架窗口，而由框架窗口创建文档的对应视图。

- 7 -

《Visual C++程序设计》

二、选做部分

1. 用MFC AppWizard(exe)创建一个单文档的应用程序

1）双击桌面上的Visual C++6.0快捷方式图标，选择文件→新建命令，在弹出的新建对话框中，选择MFC AppWizard(exe)项目类型（该类型用于创建可执行的Windows应用程序），将位置（项目工作文件夹）定位在H:\\题目二，并在工程名称中输入项目名：题目二，如图1.1所示。

图1.1 MFC AppWizard的新建对话框

2）单击确定按钮，弹出如图1.2所示的步骤1对话框，应用程序类型选择单文档。因此次程序的需要，直接单击完成按钮，便完成了单文档应用程序的创建。

图1.2 MFC AppWizard的步骤1对话框

2. 为单文档应用程序添加对话框

2.1 插入对话框

选择“插入”→“资源”菜单命令，打开“插入资源”对话框，在对话框中可以看到资源列表中存在Dialog项，单击“新建”按钮便在此程序中创建了一个对话框，如图2.1所示。

- 8 -

《Visual C++程序设计》

图2.1 “插入资源”对话框

2.2 设置对话框属性及添加和布局控件

2.2.1 设置对话框属性

在对话框模板的空白处右击鼠标，从弹出的快捷菜单中选择“属性”菜单项，弹出对话框，ID修改为IDD_DIALOG，Caption标题改为：关于sin曲线，如图2.2所示。

图2.2 对话框属性窗口

2.2.2 添加和布局控件

参看图2.3所示的空间布局，用编辑器为对话框添加如表2.1所示的一些控件。

图2.3 “关于sin曲线”对话框

表2.1 控件 静态文本 静态文本 控件 编辑框 编辑框

ID号 默认 默认 ID号 IDD_EDIT1 IDD_EDIT2 - 9 -

标题 区间起始位置： 区间结束位置： 标题 无 无 属性 默认 默认 属性 默认 默认

《Visual C++程序设计》

2.2.3 创建对话框类

在对话框资源模板的空白区域（没有其他元素或控件）内双击鼠标左键，将弹出如图2.4所示的对话框，询问是否为对话框资源创建一个新类。单击OK按钮，则为该对话框创建类，Name为：CDlg。Base class为CDialog。

图2.4 Adding a class对话框

利用ClassWizard，为表2.2所示的对话框类（CDlg）的控件增加成员变量。

表2.2 控件 编辑框 编辑框 控件ID号 IDD_EDIT1 IDD_EDIT2 变量类型 double double

变量名 m_t1 m_t2 范围和大小 -10.0—10.0 -10.0—10.0 3. 设计菜单

用编辑器设计菜单：在项目工作区打开ResourceView选项卡，展开Menu文件夹，双击IDR_MAINFRAME，右边的文档窗口出现菜单编辑器，如图3.1所示；展开“编辑”下拉菜单，如图3.2所示，删除其下所有子菜单，双击空白子菜单，弹出“菜单项属性”对话框，在Caption处写菜单名：修改参数，在ID处写：ID_AMEND。

图3.1 菜单资源编辑器

- 10 -

《Visual C++程序设计》

图3.2 菜单编辑器和修改菜单项属性

4. 编写代码

在文档类的头文件“题目二Doc.h”的class CMyDoc : public CDocument中写如下语句： public: double m_t1; //定义区间起始位置变量 double m_t2; //定义区间结束位置变量 double m_yMin; double m_yMax; CDC m_dc; bool bStart; void Draw(); double fun(double x); void Rang();

- 11 -

《Visual C++程序设计》

5. 图形绘制

5.1 运行结果

编译并运行程序，则弹出如图5.1所示的窗口，单击“文件”→“新建”，弹出写入参数对话框（关于sin曲线），写入参数如图5.2所示，点击“确定”按钮，即可得到绘制的sin曲线图如图5.3所示。

图5.1

图5.2

图5.3

- 12 -

《Visual C++程序设计》

5.2 修改参数并绘图

当绘制如图5.3时，还可通过单击“编辑”→“修改参数”，重新写入参数，令X轴起始位置为-10，X轴结束位置为10，绘制sin曲线如图5.4所示。

图5.4

6. 保存绘图结果

未保存前，此曲线图无标题，如图6.1所示，当单击“文件”→“保存”，弹出如图6.1所示的窗口，将文件名记为“sin曲线图”，点击保存即可。

图6.1

保存后此曲线标题为“sin曲线图”，如图6.2所示。

图6.2

- 13 -

《Visual C++程序设计》

附录

Dlg.cpp :

#include \#include \题目二.h\#include \#ifdef _DEBUG

#define new DEBUG_NEW #undef THIS_FILE

static char THIS_FILE[] = __FILE__; #endif

// CDlg dialog

CDlg::CDlg(double t1, double t2, CWnd* pParent /*=NULL*/) : CDialog(CDlg::IDD, pParent)

- 14 -

《Visual C++程序设计》

{ //{{AFX_DATA_INIT(CDlg) m_t1 = t1; m_t2 = t2; //}}AFX_DATA_INIT }

void CDlg::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); //{{AFX_DATA_MAP(CDlg) DDX_Text(pDX, IDC_T1, m_t1); DDX_Text(pDX, IDC_T2, m_t2); //}}AFX_DATA_MAP }

BEGIN_MESSAGE_MAP(CDlg, CDialog) //{{AFX_MSG_MAP(CDlg) //}}AFX_MSG_MAP END_MESSAGE_MAP()

// CDlg message handlers BOOL CDlg::OnInitDialog() { CDialog::OnInitDialog(); // TODO: Add extra initialization here //UpdateData(FALSE); return TRUE; // return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE }

//为“确定”按钮添加代码 void CDlg::OnOK() { UpdateData(); //数据从控件向相关联的成员变量复制编辑框的内容在按钮上显示 if(m_t1 >= m_t2) //做判断 { MessageBox(\轴起始位置必须小于X轴结束位置\ return; } CDialog::OnOK(); }

MainFrm.cpp :

- 15 -

《Visual C++程序设计》

#include \#include \题目二.h\#include \#ifdef _DEBUG

#define new DEBUG_NEW #undef THIS_FILE

static char THIS_FILE[] = __FILE__; #endif

// CMainFrame

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd) BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd) //{{AFX_MSG_MAP(CMainFrame) ON_WM_CREATE() ON_UPDATE_COMMAND_UI(ID_AMEND, OnUpdateAmend) //}}AFX_MSG_MAP END_MESSAGE_MAP() static UINT indicators[] = { ID_SEPARATOR, // status line indicator ID_INDICATOR_CAPS, ID_INDICATOR_NUM, ID_INDICATOR_SCRL, };

// CMainFrame construction/destruction CMainFrame::CMainFrame() { // TODO: add member initialization code here }

CMainFrame::~CMainFrame() { }

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) { if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1; if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) || !m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) { TRACE0(\ return -1; // fail to create }

- 16 -

《Visual C++程序设计》

if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT))) { TRACE0(\ return -1; // fail to create } m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY); EnableDocking(CBRS_ALIGN_ANY); DockControlBar(&m_wndToolBar); return 0; }

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) { if( !CFrameWnd::PreCreateWindow(cs) ) return FALSE; // TODO: Modify the Window class or styles here by modifying // the CREATESTRUCT cs return TRUE; }

// CMainFrame diagnostics #ifdef _DEBUG

void CMainFrame::AssertValid() const { CFrameWnd::AssertValid(); }

void CMainFrame::Dump(CDumpContext& dc) const { CFrameWnd::Dump(dc); }

#endif //_DEBUG

// CMainFrame message handlers

void CMainFrame::OnUpdateAmend(CCmdUI* pCmdUI) { // TODO: Add your command update UI handler code here }

题目二Doc.cpp :

#include \#include \题目二.h\

- 17 -

《Visual C++程序设计》

#include \题目二Doc.h\#include \#include #ifdef _DEBUG

#define new DEBUG_NEW #undef THIS_FILE

static char THIS_FILE[] = __FILE__; #endif

// CMyDoc

IMPLEMENT_DYNCREATE(CMyDoc, CDocument) BEGIN_MESSAGE_MAP(CMyDoc, CDocument) //{{AFX_MSG_MAP(CMyDoc) ON_COMMAND(ID_AMEND, OnAmend) ON_UPDATE_COMMAND_UI(ID_AMEND, OnUpdateAmend) ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_AS, OnUpdateFileSaveAs) ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave) //}}AFX_MSG_MAP END_MESSAGE_MAP()

// CMyDoc construction/destruction CMyDoc::CMyDoc() {

//变量初始化 m_t1 = 0.0; m_t2 = 0.0; m_yMin = 0.0; m_yMax = 0.0; bStart = true; }

CMyDoc::~CMyDoc() { }

//新建对话框

BOOL CMyDoc::OnNewDocument() { if(!bStart) { CDlg dlg; if(dlg.DoModal() == IDOK) //用户单击了“确定”按钮 { m_t1 = dlg.m_t1; m_t2 = dlg.m_t2;

- 18 -

《Visual C++程序设计》

Draw(); //调用Draw()函数 } else { return FALSE; } } else { bStart = false; } if (!CDocument::OnNewDocument()) return FALSE; // TODO: add reinitialization code here // (SDI documents will reuse this document) return TRUE; }

//绘制sin曲线图 void CMyDoc::Draw() { m_dc.DeleteDC(); Rang(); POSITION pos = GetFirstViewPosition(); //调用绘图函数 CDC *pDC = GetNextView(pos)->GetDC(); CBitmap bmp; bmp.CreateCompatibleBitmap(pDC, WIDTH, HEIGHT); m_dc.CreateCompatibleDC(pDC); m_dc.SelectObject(&bmp); CRect rc(0, 0, WIDTH, HEIGHT); m_dc.FillRect(&rc, &CBrush(RGB(255,255,255)));

//画坐标轴 m_dc.MoveTo(0, GetY(0)); m_dc.LineTo(WIDTH, GetY(0)); m_dc.MoveTo(GetX(0), 0); m_dc.LineTo(GetX(0), HEIGHT); rc.right = GetX(0) - 1; rc.top = GetY(0) + 2; rc.left = rc.right - 100; rc.bottom = rc.top + 100; m_dc.DrawText(\ char c[20]; int i;

- 19 -

《Visual C++程序设计》

}

double j;

double jg = (m_t2 - m_t1) / 5; for(j = m_t1; j <= m_t2; j += jg) { if(j == 0.0) { continue; } m_dc.MoveTo(GetX(j), GetY(0)); m_dc.LineTo(GetX(j), GetY(0) - 7); sprintf(c, \ rc.left = GetX(j) - 100; rc.right = GetX(j) + 100; m_dc.DrawText(c, &rc, DT_CENTER | DT_TOP | DT_SINGLELINE); }

jg = (m_yMax - m_yMin) / 5; rc.right = GetX(0) - 1; rc.left = rc.right - 100;

for(i = int((m_yMin - 0.5) / jg); i <= int((m_yMax + 0.5) / jg); i ++) { if(i == 0) { continue; } m_dc.MoveTo(GetX(0), GetY(i * jg)); m_dc.LineTo(GetX(0) + 7, GetY(i * jg)); sprintf(c, \ rc.top = GetY(i * jg) - 100; rc.bottom = GetY(i * jg) + 100; m_dc.DrawText(c, &rc, DT_VCENTER | DT_RIGHT | DT_SINGLELINE); }

m_dc.SetTextAlign(TA_RIGHT | TA_TOP);

m_dc.TextOut(WIDTH, GetY(0) + 2, \ //画出x轴 m_dc.TextOut(GetX(0), 0, \ //y轴

CPen pen(PS_SOLID, 1, RGB(0,0,0)); //定义黑色画笔 m_dc.SelectObject(pen); jg = (m_t2 - m_t1) / 1000;

m_dc.MoveTo(GetX(m_t1), GetY(fun(m_t1))); for(j = m_t1 + jg; j <= m_t2; j +=jg) { m_dc.LineTo(GetX(j), GetY(fun(j))); }

UpdateAllViews(NULL);

- 20 -

《Visual C++程序设计》

// CMyDoc serialization

//文件保存和打开

void CMyDoc::Serialize(CArchive& ar) { if(bStart) { bStart = false; }

//档案表头 BITMAPFILEHEADER bfh; ZeroMemory(&bfh, sizeof(bfh)); bfh.bfType = *(WORD*)\ bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); bfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO) + HEIGHT * ((WIDTH * 3 + 3) / 4 * 4);

//资讯表头 BITMAPINFO bmi; ZeroMemory(&bmi, sizeof(bmi)); bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bmi.bmiHeader.biWidth = WIDTH; bmi.bmiHeader.biHeight = HEIGHT; bmi.bmiHeader.biPlanes = 1; bmi.bmiHeader.biBitCount = 24; bmi.bmiHeader.biCompression = BI_RGB; bmi.bmiHeader.biSizeImage = HEIGHT * ((WIDTH * 3 + 3) / 4 * 4);

//保存绘图结果

if (ar.IsStoring()) { // TODO: add storing code here CDC dc; CBitmap bmp; dc.CreateCompatibleDC(&m_dc); bmp.CreateCompatibleBitmap(&m_dc, WIDTH, HEIGHT); dc.SelectObject(bmp); dc.BitBlt(0, 0, WIDTH, HEIGHT, &m_dc, 0, 0, SRCCOPY); BITMAP bm; bmp.GetObject(sizeof(bm), &bm); DWORD len = bm.bmHeight * bm.bmWidthBytes; BYTE *c = new BYTE[len];

- 21 -

《Visual C++程序设计》

bmp.GetBitmapBits(len, c); ar.Write(&bfh, sizeof(bfh)); ar.Write(&bmi, sizeof(bmi)); for(int i = bm.bmHeight - 1; i >= 0; i --) { int j; for(j = 0; j < bm.bmWidthBytes; j +=4) { ar< 0; j --) { ar<

- 22 -

《Visual C++程序设计》

AfxMessageBox(\打开文件失败\ return; } BYTE *c = new BYTE[bmi.bmiHeader.biSizeImage]; if(ar.Read(c, bmi.bmiHeader.biSizeImage) < bmi.bmiHeader.biSizeImage) { delete [] c; AfxMessageBox(\打开文件失败\ return; } delete [] c; double t1,t2; if(ar.Read(&t1, sizeof(double)) < sizeof(double)) { AfxMessageBox(\打开文件失败\ return; } if(ar.Read(&t2, sizeof(double)) < sizeof(double)) { AfxMessageBox(\打开文件失败\ return; } m_t1 = t1; m_t2 = t2; Draw(); } }

// CMyDoc diagnostics #ifdef _DEBUG

void CMyDoc::AssertValid() const { CDocument::AssertValid(); }

void CMyDoc::Dump(CDumpContext& dc) const { CDocument::Dump(dc); }

#endif //_DEBUG

//为“修改参数”添加代码 void CMyDoc::OnAmend() { CDlg dlg(m_t1, m_t2);

- 23 -

《Visual C++程序设计》

if(dlg.DoModal() == IDOK) //用户单击了“确定”按钮 { m_t1 = dlg.m_t1; m_t2 = dlg.m_t2; Draw(); } }

void CMyDoc::OnUpdateAmend(CCmdUI* pCmdUI) { // TODO: Add your command update UI handler code here pCmdUI->Enable(m_dc.m_hDC != NULL); }

void CMyDoc::OnUpdateFileSaveAs(CCmdUI* pCmdUI) { // TODO: Add your command update UI handler code here pCmdUI->Enable(m_dc.m_hDC != NULL); }

void CMyDoc::OnUpdateFileSave(CCmdUI* pCmdUI) { // TODO: Add your command update UI handler code here pCmdUI->Enable(m_dc.m_hDC != NULL); }

//定义sin曲线

double CMyDoc::fun(double x) { return sin(x); }

//定义纵坐标范围 void CMyDoc::Rang() { m_yMin = -1.0; m_yMax = 1.0; }

题目二View.cpp :

#include \#include \题目二.h\#include \题目二Doc.h\#include \题目二View.h\#ifdef _DEBUG

#define new DEBUG_NEW

- 24 -

《Visual C++程序设计》

#undef THIS_FILE

static char THIS_FILE[] = __FILE__; #endif

// CMyView

IMPLEMENT_DYNCREATE(CMyView, CView) BEGIN_MESSAGE_MAP(CMyView, CView) //{{AFX_MSG_MAP(CMyView) // NOTE - the ClassWizard will add and remove mapping macros here. // DO NOT EDIT what you see in these blocks of generated code! //}}AFX_MSG_MAP // Standard printing commands ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint) ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint) ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview) END_MESSAGE_MAP()

// CMyView construction/destruction CMyView::CMyView() { // TODO: add construction code here }

CMyView::~CMyView() { }

BOOL CMyView::PreCreateWindow(CREATESTRUCT& cs) { // TODO: Modify the Window class or styles here by modifying // the CREATESTRUCT cs return CView::PreCreateWindow(cs); }

// CMyView drawing

void CMyView::OnDraw(CDC* pDC) { CMyDoc* pDoc = GetDocument(); ASSERT_VALID(pDoc); // TODO: add draw code for native data here if(pDoc->m_dc.m_hDC) { CRect rc; GetClientRect(&rc); pDC->StretchBlt(0, 0, rc.right, rc.bottom, &pDoc->m_dc, 0, 0, WIDTH, HEIGHT, SRCCOPY);

- 25 -

《Visual C++程序设计》

} }

// CMyView printing

BOOL CMyView::OnPreparePrinting(CPrintInfo* pInfo) { // default preparation return DoPreparePrinting(pInfo); }

void CMyView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) { // TODO: add extra initialization before printing }

void CMyView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) { // TODO: add cleanup after printing }

// CMyView diagnostics #ifdef _DEBUG

void CMyView::AssertValid() const { CView::AssertValid(); }

void CMyView::Dump(CDumpContext& dc) const { CView::Dump(dc); }

CMyDoc* CMyView::GetDocument() // non-debug version is inline { ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMyDoc))); return (CMyDoc*)m_pDocument; }

#endif //_DEBUG

// CMyView message handlers

CDlg:

#if !defined(AFX_DLG_H__DBBD9A8E_F9B3_4CAA_B8F1_4CC781B25472__INCLUDED_) #define AFX_DLG_H__DBBD9A8E_F9B3_4CAA_B8F1_4CC781B25472__INCLUDED_ #if _MSC_VER > 1000 #pragma once

#endif // _MSC_VER > 1000

- 26 -

《Visual C++程序设计》

// Dlg.h : header file

// CDlg dialog

class CDlg : public CDialog {

// Construction public: CDlg(double t1 = 0.0, double t2 = 0, CWnd* pParent = NULL); // standard constructor // Dialog Data //{{AFX_DATA(CDlg) enum { IDD = IDD_DIALOG1 }; double m_t1; double m_t2; //}}AFX_DATA // Overrides // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CDlg) protected: virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL // Implementation protected: // Generated message map functions //{{AFX_MSG(CDlg) virtual BOOL OnInitDialog(); virtual void OnOK(); //}}AFX_MSG DECLARE_MESSAGE_MAP() };

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_DLG_H__DBBD9A8E_F9B3_4CAA_B8F1_4CC781B25472__INCLUDED_)

MainFrm.h :

#if !defined(AFX_MAINFRM_H__A50B5AD1_B4B6_48B7_B400_56375424FCEC__INCLUDED_) #define AFX_MAINFRM_H__A50B5AD1_B4B6_48B7_B400_56375424FCEC__INCLUDED_ #if _MSC_VER > 1000 #pragma once

#endif // _MSC_VER > 1000

class CMainFrame : public CFrameWnd {

protected: // create from serialization only CMainFrame();

- 27 -

《Visual C++程序设计》

DECLARE_DYNCREATE(CMainFrame) // Attributes public:

// Operations public: // Overrides // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CMainFrame) virtual BOOL PreCreateWindow(CREATESTRUCT& cs); //}}AFX_VIRTUAL // Implementation public: virtual ~CMainFrame(); #ifdef _DEBUG virtual void AssertValid() const; virtual void Dump(CDumpContext& dc) const; #endif

protected: // control bar embedded members CStatusBar m_wndStatusBar; CToolBar m_wndToolBar; // Generated message map functions protected: //{{AFX_MSG(CMainFrame) afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); afx_msg void OnUpdateAmend(CCmdUI* pCmdUI); //}}AFX_MSG DECLARE_MESSAGE_MAP() };

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line. #endif

// !defined(AFX_MAINFRM_H__A50B5AD1_B4B6_48B7_B400_56375424FCEC__INCLUDED_)

题目二.h :

#if !defined(AFX__H__69D88648_2A41_47C4_BBF4_DB6577287838__INCLUDED_) #define AFX__H__69D88648_2A41_47C4_BBF4_DB6577287838__INCLUDED_ #if _MSC_VER > 1000 #pragma once

#endif // _MSC_VER > 1000 #ifndef __AFXWIN_H__ #error include 'stdafx.h' before including this file for PCH #endif

- 28 -

《Visual C++程序设计》

#include \ // main symbols

// CMyApp:

// See 题目二.cpp for the implementation of this class class CMyApp : public CWinApp {

public: CMyApp(); // Overrides // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CMyApp) public: virtual BOOL InitInstance(); //}}AFX_VIRTUAL // Implementation //{{AFX_MSG(CMyApp) afx_msg void OnAppAbout(); // NOTE - the ClassWizard will add and remove member functions here. // DO NOT EDIT what you see in these blocks of generated code ! //}}AFX_MSG DECLARE_MESSAGE_MAP() };

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line. #endif // !defined(AFX__H__69D88648_2A41_47C4_BBF4_DB6577287838__INCLUDED_)

题目二Doc.h :

#if !defined(AFX_DOC_H__3F0BFB62_FAED_4497_9BD9_281FF300454F__INCLUDED_) #define AFX_DOC_H__3F0BFB62_FAED_4497_9BD9_281FF300454F__INCLUDED_ #if _MSC_VER > 1000 #pragma once

#endif // _MSC_VER > 1000

class CMyDoc : public CDocument {

protected: // create from serialization only CMyDoc(); DECLARE_DYNCREATE(CMyDoc) // Attributes public:

// Operations public: // Overrides // ClassWizard generated virtual function overrides

- 29 -

《Visual C++程序设计》

//{{AFX_VIRTUAL(CMyDoc) public: virtual BOOL OnNewDocument(); virtual void Serialize(CArchive& ar); //}}AFX_VIRTUAL // Implementation public: virtual ~CMyDoc(); #ifdef _DEBUG virtual void AssertValid() const; virtual void Dump(CDumpContext& dc) const; #endif protected:

// Generated message map functions protected: //{{AFX_MSG(CMyDoc) afx_msg void OnAmend(); afx_msg void OnUpdateAmend(CCmdUI* pCmdUI); afx_msg void OnUpdateFileSaveAs(CCmdUI* pCmdUI); afx_msg void OnUpdateFileSave(CCmdUI* pCmdUI); //}}AFX_MSG DECLARE_MESSAGE_MAP()

//定义公共变量和函数 public: double m_t1; double m_t2; double m_yMin; double m_yMax; CDC m_dc; bool bStart; void Draw(); double fun(double x); void Rang(); inline int GetX(double x) { double t1 = min(0.0, m_t1); double t2 = max(0.0, m_t2); return (int)((x - t1) * (WIDTH - 100) / (t2 - t1) + 50); } inline int GetY(double y) { return int(HEIGHT - 50 - (y - m_yMin) * (HEIGHT - 100) / (m_yMax - m_yMin));

- 30 -

《Visual C++程序设计》

} };

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_DOC_H__3F0BFB62_FAED_4497_9BD9_281FF300454F__INCLUDED_)

题目二View.h :

#if !defined(AFX_VIEW_H__A5AAED43_A2AA_4634_86CE_17274F348D0E__INCLUDED_) #define AFX_VIEW_H__A5AAED43_A2AA_4634_86CE_17274F348D0E__INCLUDED_ #if _MSC_VER > 1000 #pragma once

#endif // _MSC_VER > 1000 class CMyView : public CView {

protected: // create from serialization only CMyView(); DECLARE_DYNCREATE(CMyView) // Attributes public: CMyDoc* GetDocument(); // Operations public: // Overrides // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CMyView) public: virtual void OnDraw(CDC* pDC); // overridden to draw this view virtual BOOL PreCreateWindow(CREATESTRUCT& cs); protected: virtual BOOL OnPreparePrinting(CPrintInfo* pInfo); virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo); virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo); //}}AFX_VIRTUAL // Implementation public: virtual ~CMyView(); #ifdef _DEBUG virtual void AssertValid() const; virtual void Dump(CDumpContext& dc) const; #endif protected:

// Generated message map functions

- 31 -

《Visual C++程序设计》

protected: //{{AFX_MSG(CMyView) // NOTE - the ClassWizard will add and remove member functions here. // DO NOT EDIT what you see in these blocks of generated code ! //}}AFX_MSG DECLARE_MESSAGE_MAP() };

#ifndef _DEBUG // debug version in 题目二View.cpp inline CMyDoc* CMyView::GetDocument() { return (CMyDoc*)m_pDocument; } #endif

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_VIEW_H__A5AAED43_A2AA_4634_86CE_17274F348D0E__INCLUDED_)

- 32 -

本文来源：https://www.bwwdw.com/article/tv18.html