优秀的编程知识分享平台

网站首页 > 技术文章 正文

简单C++程序详解（c++简单程序设计）

nanyue 2024-07-18 22:20:14 技术文章 14 ℃

完整的一个C++程序

1.头文件.h

2.源文件.cpp

3.程序接入口文件main.cpp

4.C++标准函数库文件std

命名空间（using namespace std）

命名空间是C++的一种机制，用来把单个标识符下的大量有逻辑联系的程序实体组合到一起。此标识符作为此组群的名字。命名空间实际上是一种将程序库名称封装起来的方法，它就像在各个程序库中立起一道道围墙。

命名空间namespace：标识符的各种可见范围。

命名空间对象 std: 里面包括了C++标准程序库中的所有标识符，包括了各种有逻辑联系的程序实体，是常见的函数算法程序族群。

关键字using：表示引用std对象中的C++标准函数库可见标识符。

using namespace std : 表示引用命名空间std封装好的标准程序库的名称。

优点（解决问题）：

避免导致全局命名冲突问题。（98以后的全局命名空间）

使用方法：

1.直接指定标识符

std::cout<<std::π<<3.14<<std::endl;

2.使用using关键字

using std::cout; 
using std::π;
using std::endl;
cout<<π<<3.14<<endl;

3.使用using namespace std

using namespace std;
#include <iostream>
cout<<π<<3.14<<endl;

类的定义和声明

面向对象的最大特征就是提出了类和对象的概念。类是对事物数据的抽象及处理。

类包括数据的定义和操作数据的方法。 对象是对类的访问，用户通过实例化类对象来实现对类中的数据和方法的访问。

1.类定义：

	class/struct 类名 //类头
{
 数据和方法的定义（可能含有类型成员） //类体
}

class和struct的唯一区别：

Class定义的类在没有被强制限定的话，其成员是私有的，即不能被外部调用。

struct定义的类，其成员是公共的，可以被外部调用。

注：

  • 每个类定义了唯一的类型，只要类名不同，即不为同一类型。
  • 类体中的数据：描述类的特征，即属性；描述类的行为/方法，即定义的函数。类型成员用于在类的作用域中指定类型的别名。

成员函数的解析过程

（1）首先，在成员函数内查找该名字的声明。只有在函数使用之前出现的声明才会被考虑。

（2）如果在成员函数内没有找到，则在类内继续查找，这时类的所有成员都可以被考虑。

（3）如果类内也没有找到该名字的声明，在类定义和成员函数定义之前的作用域内继续查找。

注：

一般最好不要使用其它成员的名字作为某个成员函数的参数。可以通过作用域运算符强制指定是哪个名字。

类型成员

  1. 除了定义数据和方法以外，类还可以自定义某种类型成员它是类型在类中的别名（使用typedef或using(C++11)）
  2. 由类定义的类型名字和其他成员一样存在访问权限。
  3. 类类型成员使用作用域运算符::访问。
  4. 用来定义类型的成员必须先定义后使用，类型成员通常出现在类开始的地方。
  5. 一般来说，内层作用域可以重新定义外层作用域中的名字，即使该名字已经在内层作用域中使用过。
  6. 可以在定义类的同时定义定义对象

例1：

/*内层作用域可以重新定义外层作用域中的名字，即使该名字已经在内层作用域中使用过。*/
typedef char I; 
int main()
{
cout<<sizeof(I)<<endl; //I为char
 typedef int I;
 cout<<sizeof(I)<<endl; //I为int
}

例2：

/*在类中，如果成员使用了外层作用域中的某个名字，而该名字代表一种类型，即使两次定义完全一样，也是错误的行为（这一点不同于内层作用域中的名字查找规则）。有些编译器并不会报错，而忽略代码有错的事实。*/
typedef char I ;
struct part 
{
 I a ; //定义I为char
 typedef int I ; //重新定义I 为int -----错误×，不能重新定义I ，虽然编译可能不报错。
 I b ;
};

编译器处理类步骤

1.首先编译成员的声明；

2.处理完所有声明后然后才轮到成员函数体。

注：

成员函数体可以随意使用类中的其他成员而无须在意这些成员出现的次序。但是需要注意声明中使用的名字，包括返回类型或者参数列表中使用的名字，都必须在使用前确保可见。如果某个成员的声明使用了其声明语句之前类中尚未出现的名字，则编译器将会在类的作用域外继续查找。

使用访问说明符加强类的封装性

Public：

定义在public说明符之后的成员在整个程序内可被访问，public定义类的接口。

Private：

定义在private说明符之后的成员可以被类的成员函数访问，但是不能被使用该类的代码访问也不能被派生类访问，private部分封装（隐藏）了类的实现细节。

Protected：

定义在protected之后的成员被称为保护成员，该成员只能在该类和该类的派生类（子类）中访问。

注：

  • 访问说明符的优先级是高于使用class和struct的默认访问属性的。
  • 一个类可以包含任意数量的访问说明符。

求解点在圆内的C++程序算法

问题描述：

点是否在圆内？

问题分析:

1.对象2个：点Point P（x,y）和圆Circle C（Point O（a,b）,r）---建立两个类Point和Circle

2.点的特征描述：Point类中参数和方法的定义和声明---头文件：Point.h

3.点的行为/方法描述：Point类中参数和方法的实现(使用描述)---Point方法类：Point.cpp

4.圆的特征描述：Circle类中参数和方法的定义和声明---头文件：Circle.h

5.圆的行为/方法描述：Circle类中参数和方法的实现（使用描述）---Circle方法类：Circle.cpp

6.程序接入函数main()的设置--创建类的实例化对象（输入参数），实现对类中方法的调用并输出结果（输出参数）

注：

1. 点Point的参数及方法{ parameters x ，横坐标；parameters y ,纵坐标；Point（int x,int y）带参点函数实现方法；point（）不带参点函数实现方法 }

2. 圆Circle的参数及方法{parameters r ,圆半径； Point o , 圆心 ； Circle（point o ,double r1）,带参圆函数实现方法；Circle（），不带参圆函数实现方法；bool IsInCircle(Point P)，判断点P是否在圆内的函数实现方法}

3.main()中的实现{ 创建点对象P ,圆心O ; 创建圆对象C（O，r）; 创建bool对象b，实现判断的输出}

Point.h头文件(函数定义和声明)的编写

#pragma once //表示只读一次
//********************变量、函数的声明*****************
// 点Point（）函数的声明
class Point
{
public:
	int GetX(); //声明函数GetX();得到点Point的横坐标
	int GetY(); //声明函数GetY();得到点Point的纵坐标
	Point(int x ,int y); //点Point的表达方式/定义
	Point();
private:
		int x; //定义私有变量 x,令 x = Getx():
		int y; //定义私有变量 y,令 y = Gety();
};

注：

在类Point中，设置公共函数方法GetX()、GetY()来实现对点P的x,y坐标的获取，起到保护隔离目标参数的作用。

头文件中：

#pragma once

#pragma once实质是C/C++语言中的宏定义，通过宏定义避免文件多次编译。它是一个比较常用的C/C++杂注，只要在头文件的最开始加入这条杂注，就能够保证头文件只被编译一次。

Point.cpp方法实现文件的编写

#include "Point.h" //#include 表示在程序运行的时候可提供随时调用的文件（声明的变量和函数等）
//--封装之一--变量和函数的声明。
//声明变量的使用和 声明函数的实现过程
//GetX ()函数：实现x的输出
int Point::GetX() 
{
	return x;
}
//GetY（）：实现y的输出
int Point::GetY()
{
	return y;
}
//函数Point(int x1,int y1)：实现点Point的设置
Point::Point(int x1, int y1)
{
	x = x1;
	y = y1;
}
Point::Point()
{
}

注：

#include “Point.h”: 表示调用Point.h头文件中的函数定义及参数，实质是起到一个文档连接作用。将Point.h文档程序和Point.cpp文档程序连接起来使用。

int Point::GetX() ：其中 ::表示作用域运算符；当定义在类的外部(point.h)时，函数名之前需要加上类名和作用域运算符（::）以显式的指出该函数是对应类的成员函数，并且定义需与声明匹配。

Circle.h头文件(函数定义和声明)的编写

#pragma once
#include "Point.h"
class Circle
{
public:
	double GetOR(); //声明获得半径r的方法
	Point GetOO(); //声明获得圆心o的方法
	bool IsInCircle(Point P); //声明判断点P是否在圆内方法定义
	Circle(Point O, double r1); //声明获得圆的方法定义
	Circle(); 
private:
	Point o; //定义圆心参数
	double r; //定义半径参数
};

注：

在改程序段中，用到了点Point的相关定义和方法。因此需要包括进“Point.h”头文件。

Circle.cpp方法实现文件的编写

#include "Circle.h"
#include "Point.h"
double Circle::GetOR()
{
	return r;
}
Point Circle::GetOO()
{	
	return o;
}
bool Circle::IsInCircle(Point P)
{
	if (((P.GetX() - o.GetX())*(P.GetX() - o.GetX()) + (P.GetY() - o.GetY())*(P.GetY() - o.GetY())) >= r*r)
	{
	return false;
	}
	else
	{
		return true;
	}	
}
Circle::Circle(Point O ,double r1)
{
	O = o;
	r = r1;
}
Circle::Circle()
{
}

判断点是否在圆内的具体方法为：

(((P.GetX() - o.GetX())*(P.GetX() - o.GetX()) + (P.GetY() - o.GetY())*(P.GetY() - o.GetY())) <= r*r)

即：

(x1-ox)^2 + (y1-oy)^2 ?<= r^2

判断：

小于在圆内；等于在圆上；大于在圆外。

程序接入口函数文件main.cpp的编写

#include "Circle.h" //引用头文件CIrcle.h
#include "Point.h" //引用头文件Point.h
#include <iostream> //引用输入输出流文件
using namespace std; //引用C++标准函数库标识符
int main()
{
	Point O = Point(0, 0); //创建点对象：O（0，0） --引用头文件Point.h
	Circle C = Circle(O,5); //创建圆对象：C（O，5） --引用头文件CIrcle.h
	Point p1 = Point(1,2); //创建点对象： p1(1,2); --引用头文件Point.h
	bool b = C.IsInCircle(p1); //创建bool判断函数对象 b(true,false) --引用头文件CIrcle.h
	if(b ==false)
	{
		cout << "点p1在圆上或者圆外！" << endl; //输出判断结果b ----引用<iostream>/ 引用C++标准函数库
	}
	else
	{
		cout << "点p1在圆内！" << endl; //输出判断结果b ----引用<iostream>/ 引用C++标准函数库
	}
	system("pause"); //system就是从程序中调用系统命令（和shell命令）system("pause")就是从程序里调用“pause”命令； 
	//而“pause”这个系统命令的功能很简单，就是在命令行上输出一行类似于“Press any key to exit”或“请按任意键继续...”的字，等待用户按一个键，然后返回。
	return 0; //main()函数返回值 ---引用C++标准函数库/引用C++标准函数库	
}

注：

main()函数主要作用：提供程序接入口，通过类的实例化对象的创建以及初始化（输入参数），调用函数方法解决相应问题，实现问题结果的输出（输出参数），完成整个算法的执行。3

system("Pause")：作用是从程序中调用系统命令和shell命令（类似dos命令），pause系统命令作用：在命令行上输出一行类似于”Press any key to exit”或“请按任意键继续...”的字，等待用户按一个键，然后返回。

本文部分内容来参考至扩展链接，如有错误，敬请指正，如有侵权，请联系修改。

Tags：

猜你喜欢

最近发表
标签列表