标题输入一个八位二进制 化为十进制
if include < iostream>
using namespace std;
//计算x 的口次方
double power (double x , int n) ;
int main () {
int value=O;
cout<< "Enter an 8 bi t binary number: ";
for (int i=7; i>=O; i--) {
char ch;
cin>>ch;
if (ch== '1')
va1ue+=static_cast< int> (power (2 , i));//强制类型转化
cout<<"Decimal va1ue is "<<va1ue<<end1;
return 0;
doub1e power (double x , int n) {
double val= 1 .0;
while (n--)
va1 *= Xi
return va1;
编写程序求π 的值，公式如下。
π= 16arctan( 1/5）-4arctan(1/239)
arctanx 用泰勒展开
//3 3.cpp
# incl ude < iostream>
using namespace std;
double arctan (double x) {
double sqr=x*x;
double e=x;
double r=O;
int i=l;
while (e/i> 1e-15) {
double f=e/i;
r=(i%4==l)?r+f: r-f;
e=e*sqr;
i+ = 2;}
return r
}
int main () (
double a=16.0 *arctan(1/5.0);
doub1e b= 4.0 *arctan( 1/ 239.0);
//注意:因为整数相除结果取整，如果参数写为1/5 ， 1/239 ，结果就都是0。
cout<<"PI="<<a-b<<end1;
return 0;
sinx近似值
（泰勒级数展开）
include < iostream>
inc1ude <crnath> //头文件cmath 中具有对C++ 标准库中数学函数的说明
using namespace std;
const double TINY VALUE= 1e-10;
double tsin (double x) {
double g= 0;
double t=x;
int n=l;
do {
g+=t;
n++ ;
t=-t *x *x/(2 *n-l)/(2 *n- 2) ;
} while (fabs (t) >=TINY VALUE);
return g;
}
int main () {
doub1e k , r , s;
cout<< "r=" ;
cin>>r;
cout<< "s=";
cin>> s;
if (r *r<=s *s)
k=sqrt(tsin(r) *tsin(r) +tsin(s) *tsin(s));
else
k=tsin (r *s) /2;
cout<< k<< end1;
return 0;
类的友元
实现一个类Y,类X，类Y中的成员函数g(X*)是X的友元函数，实现对X的私有成员i加一,h(X*)是X的友元函数，实现对x的私有成员加十:
class X;//前向引用声明
class Y{
void g(X*);
}
class X{
private:i;
public:
X(){
i=0;}
friend void Y::g(X*);
friend class z;//友元类
friend void h(X*);//并非是某一个类的成员函数，是一个一般的友元函数
};
void h(X*x)
{
x->i +=10;
}
void Y::g(X*x)
{
x->i++;}
class Z{
public:
void f(X*x){
x->i+=5;}
};
指针和引用的使用
定义一个整型变量a,一个整型指针p,一个引用r,通过p把a的值改为10，通过r把a的值改为5
int a;
int *p = &a;
int&r = a;
*p =10;
r = 5;
编写函数int index(char s,chart),返回子串t在字符串s中出现的最左边的位置，若没有出现 返回-1
int index(char*s,char*t){
int j,k;
for(int i = 0;s[i] != '\0';i++)
{
for(j = i,k = 0;t[j]!='\0'&&s[j]==t[j];j++);
if(t[j] == '\0') return i;
}
return -1;//如果for循环中一直没有return出去，说明s中无t,返回-1
}
重载下标运算符 重载指针转化运算符
我们经常会写这样的表达式: a[3]=5 。这时"[ ]" 运算
的结果被放在等号左边，称为左值。
如果一个函数的返回值是→个对象的值，它是不应成为左值的，对于"十"，"一"这样的运算符，以对象类型作为返回值是应该的，因为对其结果赋值没有任何意义。然而
"[]“运算符就不同了，恰恰经常需要将它作为左值。实现这个愿望的办法就是，将”[]重载函数的返回值指定为引用。由于引用表示的是对象的别名，所以通过引用可以改变对象的值。
//数组类模板定义
template< class T>
class Array {
private:
T *list;
int size;
public:
Array(int sz=50);
Array (const Array<T> &a) ;
~ Array () ;
Array<T>& operator= (const Array<T>&rhs);//重载=
T & operator [] (int i);//重载[]
const T & operator [] (int i) const;/ /" []"运算符针对const 的重载
operator T *(); / /重载到T* 类型的转换，使Array 对象可以起到C++ 普通数组的作用
int getSize () const; / /取数组的大小
void resize (int sz);
}
template<class T>
Array<T>: :Array (int sz) {
assert (sz >=0);
size=sz;
list=new T [size];//动态分配size个T类型的元素空间
}
template<class T>
Array< T> : : -Array () {
delete [] list;}
//复制构造函数
template<class T>
Array<T>: :Array (const Array<T> &a) {
size=a.size;
list=new T [size];
for (int i=0; i<size;i++)
list[i]=a.list[i];}
//重载下标运算符，实现与普通数组一样通过下标访问元素，并且具有越界检查功能
template<class T>
T &Array<T>: :operator[] (int n) {
assert (n >=0 && n<size);
return list [n]
}
template<class T>
Array<T>&Array<T>: :operator= (const Array<T>& rhs)
{
if (&rhs !=this) {
//如果本对象中数组大小与rhs 不同，则删除数组原有内存，然后重新分配
if (size! =rhs. size)
{
delete [] list;
size=rhs.size;
list=new T [size];
}
//从对象rhs 复制数组元素到本对象
for (int i=0; i<size; i++)
list[i]=rhs.list[i];
}
return *this;
}
//重载指针转换运算符，将Array 类的对象名转换为T 类型的指针，
//指向当前对象中的私有数组，
//因而可以像使用普通数组首地址一样使用Array 类的对象名
template< class T>
Array< T> : : operator T*()
{
return list;
}
语法规定"="， “[]” ，"()"，"->"只能被重载为成员函数，而且派生类中的‘=“运算符函数总会隐藏基类中的”="运算符函数。
直接插入排序函数模板
temp1ate<c1ass T>
void insertionSort (T a [] , int n) {
int i, j;
T temp;
//将下标为1-n-1 的元素逐个插入到已排序序列中适当的位置
for (int i= 1; i<n; i++) {
//从a [i-1] 开始向a [0] 方向扫描各元素，寻找适当位置插入a [i]
int j= i;
T temp=a [i];
while (j>O && temp<a[j-1])
//当temp > a[j-1]时，j是应该插入的位置
//若达到j == 0，则0是应该插入的位置
{
a[j] = a[j-1];
j--;//元素逐个后移，以便找到插入位置时可立刻插入
}
a[j] = temp;
}
选择排序
选择排序的基本思想是:每次从待排序序列中选择一个关键字最小的元素(当需要按关键字升序排列时) ，顺序排在已排序序列的最后，直至全部排完。在选择类排序方法中，根据从待排序序列中选择元素的方法不同，又分为不同的选择排序方法。其中最简单的是通过顺序比较找出待排序序列中的最小元素，称为直接选择排序
直接选择排序函数模板：
template< class T>
void mySwap (T &x , T &y) {
T temp=x;
x=y;
y= temp;
}
template<class T>
void selectionSort (T a [], int n)
{
for (int i=O; i<n-l; i++) {
int leastlndex=i; //最小元素的下标初值设为i
for (int j=i+1; j<n; j++)
ìf (a[j]<a[leastlndex])
leastlndex=j;
mySwap(a[i] , a[leastlndex]); //将这一趟找到的最小元素与a[i] 交换
}
}
交换排序
交换排序的基本思想是:两两比较待排序序列中的元素，并交换不满足顺序要求的
各对元素，直到全部满足顺序要求为止。最简单的交换排序方法是起泡排序。
对具有n 个元素的序列按升序进行起泡排序的步骤如下。
(1)首先将第一个元素与第二个元素进行比较，若为逆序，则将两元素交换。然后比较第二、第三个元素，以次类推，直到第n-l 和第n 个元素进行了比较和交换。此过程称为第一趟起泡排序。经过第一趟，最大的元素便被交换到第n 个位置。
(2) 对前n-1 个元素进行第二趟起泡排序，将其中最大元素交换到第n-1 个位置。
(3) 如此继续，直到某一趟排序未发生任何交换时，排序完毕。对n 个元素的序列，
起泡排序最多需要进行n-l 趟。
template<class T>
void bubb1eSort (T a [], ìnt n)
{
ìnt ì=n-1; //i是下一趟需参与排序交换的元素的最大下标
while (i>O) {
//继续排序过程，直到最后一趟排序没有交换发生，或已达n-1 趟
ìnt lastExchangelndex= 0; //每趟开始时，设置交换标志为0 (未交换)
for (ìnt j=O; j<ì; j++) 11每一趟对元素a [0] ..a [i] 进行比较和交换
if (a[j+1]<a[j]) {
mySwap(a[j] , a[j+1]);
lastExchangelndex= j; / /记录被交换的一对元素中较小的下标
}
i=lastExchangelndex;//将i设置为本趟被交换的最后一对元素中较小的下标
}
}