c++编程例子简单（c++编程，设计一个简单的c++程序）

#include《iostream》using namespace std;int main(){ int a= {0,2,1,5,1,12,2,1,1,1,1,0,63,95,101,1,2,58,96,100}; int b(1); int *p=a; int t1(0),t2(0); for(int i=0; i《20; ) { if (p==b) { ++i; ++t1; continue; } else if(i+1《20) { if(p==b) { i+=2; ++t1; continue; } else { i+=2; ++t2; continue; } }} cout《《“找到相同的数“《《t1《《“次“《《endl; cout《《“找到不相同的数“《《t2《《“次“《《endl; return 0;}看看是不是这个意思

代码如下！如果网页上的排版看不清，可以下载附件中的cpp文件，用vc打开查看。运行效果如图：

#include 《iostream》

using namespace std;

class DATA

{

private:

int* a;//整数指针，指向动态分配的数组空间

int n;//数组中元素个数

public:

DATA(int t, int n1) ;  //构造函数，用n1初始化n，并根据n动态生成数组a，用t数组对a数组初始化

int belong(int a, int n, int x) ;  //判断x的值是否在数组a中，如果在返回1，否则返回0

void fun( ) ;//判断求余运算%对本对象是否封闭，如果封闭，输出“封闭”。如果不封闭，则输出“不封闭”，同时输出第一个不满足条件的a。

void print( ) ;  //输出成员数据的值。

~DATA( ) ;//析构函数，完成必要的功能。

};

DATA::DATA(int t, int n1)

{

n = n1;

a = new int;

//for(int i = 0; i 《 n; i++)

//a;

memcpy(a, t, sizeof(int) * n);

}

int DATA::belong(int a, int n, int x)

{

for(int i = 0; i 《 n; i++)

if(a == x)

return 1;

return 0;

}

void DATA::fun( ) 

{

int mod;

for(int i = 0; i 《 n; i++)

for(int j = 0; j 《 n; j++)

if(i == j || 0 == a)

;

else

{

mod = a;

if(belong(a, n, mod))

;

else

{

cout《《“不封闭：“《《a《《endl;

return;

}

}

cout《《“封闭“《《endl;

}

void DATA::print( ) 

{

cout《《“集合： “;

for(int i = 0; i 《 n; i++)

cout《《a《《“ “;

cout《《endl;

}

DATA::~DATA( )

{

delete a;

}

int main()

{

int d1 = {1, 3, 22, 4, 15, 2, 7, 5, 0};

int d2 = {1, 3, 8, 4, 6, 7, 5, 0};

DATA test1(d1, 9);

DATA test2(d2, 8);

test1.print();

test1.fun();

test2.print();

test2.fun();

system(“pause“);

return 0;

}

#include《iostream.h》void main(){ int arr,i,oddsum(0),evensum(0); cout《《“请输入十个整数：“; for(i=0;i《10;i++) cin》》arr; for(i=0;i《10;i++) { if(arr%2==0) evensum+=arr; else oddsum+=arr; } cout《《“奇数项之和为：“《《oddsum《《endl; cout《《“偶数项为：“《《evensum《《endl;}

C++中的多态（虽然多态不是C++所特有的，但是C++中的多态确实是很特殊的）分为静多态和动多态（也就是静态绑定和动态绑定两种现象），静动的区别主要在于这种绑定发生在编译期还是运行期，发生在编译期的是静态绑定，也就是静多态；发生在运行期的则是动态绑定，也就是动多态。静多态可以通过模板和函数重载来实现（之所说C++中的多态主要还是因为模板这个东西），下面举两个例子：1）函数模板template 《typename T》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;}即将所有的T替换成int;当你调用max(c, d)时就自动生成一个函数float max(const float& lsh, const float& rhs){ return (lsh 》 rhs) ? lsh : rhs;}之所以说开始的函数定义是函数模板，就是因为他就像个模子似的，你可以用铝作为原料也可以用石膏或者铜。2）函数重载：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 《typename T》T max(const T& lsh, const T& rhs) { return (lsh 》 rhs) ? lsh : rhs;}template 《typename T》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通过参数个数和类型，编译器自动生成和调用对应得函数版本！动多态则是通过继承、虚函数(virtual)、指针来实现。class A {public: virtual void func() const { coust 《《 “A::func()” 《《 endl; }}class B : public A {public: virtual void func() const { coust 《《 “B::func()” 《《 endl; }}使用：A a* = B();a-》func();输出： B::func()编译期是不调用任何函数的，编译器编译到a-》func()时只是检查有没有语法问题，经过检查没有。编译器并不知道调用的是A版本的func()还是B版本的func()，由于a是一个指向B对象的指针，所以a只知道它指向的是一个A类型（或者能转换成A类型）的对象。通常集成体系就说明了（由于是公有继承）B是一种A。在运行期，a要调用a所指向对象的func()函数，就对它指向的对象下达调用func()的命令，结果a所指向的是一个B对象，这个对象就调用了自己版本（B版）的func()函数，所以输出时B::func()总结：在编译期决定你应该调用哪个函数的行为是静态绑定（static-binding)，这种现象就是静多态。在运行期决定应该调用哪中类型对象的函数的行为是动态绑定（dynamic-binding），这种现象就是动多态

#include《iostream》using namespace std;int NumRoot(int n) //求数根算法{ int sum = 0; //n的各个数位之和为sum while (n != 0) //循环对n取余即可分离各个数位 { sum = sum + n%10; n = n/10; } if (sum 》 9) //如果sum为两位数，还要继续求数根 return NumRoot(sum); return sum;}int main(){ int n; cout《《“输入一个整数：“; cin》》n; cout《《n《《“的数根是：“《《NumRoot(n)《《endl;}

#include 《fstream》#include 《string》#include 《iostream》using namespace std;int main(){ bool isupper(char); bool islower(char); bool isdigit(char); string s=““; int upper, lower, number; upper = lower = number = 0; cin 》》 s;

for (int i =0; i 《 s.length(); ++i) { if (isupper(s)) ++upper; else if (islower(s)) ++lower; else if (isdigit(s)) ++number; }

cout 《《 “Number of upper case letters, lower case letters and digits are: “ 《《 endl; cout 《《 upper 《《 ’ ’ 《《 lower 《《 ’ ’ 《《 number 《《 endl;} bool isupper(char c){ return (c》=’A’ && c《=’Z’);}bool islower(char c){ return (c》=’a’ && c《=’z’);}bool isdigit(char c){ return (c》=’0’ && c《=’9’);}

int prime(int i){ int j=2; for(j=2;j*j《=i;j++) { if(i%j) return 0; } return 1;}int main(){ int i,j; scanf(“%d“,&i); j=0; if(prime(i)){ while(i){ j=j*10+i%10; i=i/10; } if(prime(j)) printf(“yes\n“); else printf(“no\n“); } else printf(“no\n“);return 0;}

限于整型数据的数据范围，所以实际上这个程序只能求n《=12的情况。如果想求更大的，必须为这个阶乘自定义一个数据类型。

#include《iostream》      using namespace std;

int fact(int n);     int main(){

 int n;    cout《《“求n!，请输入n：\n“;

 cin》》n;   cout《《fact(n)《《endl;

 return 0;}

//下面是使用递归函数求n！

int fact(int n){     if(n==1) return(1);

 else     return(fact(n-1)*n)}

一个简单的c++编程例子:

定义一个圆锥体类（yzt），数据成员有半径r，高h，成员函数有：构造函数、求圆锥体体积的valume（），显示函数display（），在main（）中定义yzt 的对象s，求r=h=1时的体积，公式：π/3rrh

#include 《iostream》using namespace std;//定义标准命名空间

class yzt //定义yzt类{

private:double r,h;

public:yzt(double x=0,double y=0)// 为yzt的构造函数，功能是为r，h赋值

{ r=x;h=y; }double valume()//求圆锥体的体积函数

{ double v=0;v=(3.1415/3)*r*r*h;

return v; }void display() //圆锥体的体积显示函数

{cout《《“圆锥体的体积为:“《《valume()《《endl;}

};int main() //主函数，任何程序都必须有一个main（）函数，因为要从它开始执行

{

yzt s(1,1); //定义yzt的对象s.display(); //利用对象s调用yzt的display（）函数

return 0;

#include #include #include void select(); /*自定义函数的全局声明*/ void input(); void output(); void sort(); void search(); void modify(); void deleted(); void save(); void load(); struct student { int number; char name.zy);

arxhert说的对运算符如果重载为类的成员函数,那么调用时,类的实例本身就是第一个参数