简单程序设计

C++的完全兼容了 C语言结构化程序设计

隐含数据类型转换

逻辑运算操作必须为 bool

非0转换为 true ，0转换为 false
位运算必须是整数

字节数少的转换为字节数多的类型

赋值运算一律将右值转换为左值

显示数据类型转换

C语言的数据类型转换很简单

TYPE b = (TYPE) a;

C++的类型转换提供更好的控制强制转换过程，允许控制各种不同种类的强制类型转换

static_cast

静态转换：可以实现内置基本数据类型之间的转换

TYPE b = static_cast<TYPE>(a);

只能在有联系的类型之间相互转换
不一定包含虚函数
在编译时进行转换

用于基类和子类之间转换

子类指针转换成父类指针是安全的

父类指针转换成子类指针是不安全的
基本数据类型转换
把空指针转换成目标类型的空指针
把任何类型的表达式转换成void类型

int a = 6;
double b = static_cast<int>(a);
int *pn = &a;
double *d = static_cast<double *>(pn);
void *p = static_cast<void *>(pn);

const_cast

常量转换：用于取出const属性（把const指针转换为非const指针）

不能转换不同类型的白能量
只能用于指针或常引用
在编译时转换

const int a= 0;
int b = const_cast<int>(a);//不对
const int *pi = &a;
int * pii = const_cast<int *>pi;//去除指针中的常量性，也可以添加指针的常量性;

struct S{
	int i;
};
const S ra;
//ra.i = 10; //编译报错，不能直接修改const类型
S &rb = const_cast<S &>(ra);
rb.i = 10；//编译通过

reinterpret_cast

重新解释转换：转换一个指针为其他类型指针

操作结果只是简单的从一个指针到别的指针的值拷贝

指针，引用，算法类型，函数指针或成员指针
编译时
用于 多态类 ，函数指针类型之间的转换

/*
reinterpret_cast把一个指针转换成一个整数，
也可以把一个整数转换成一个指针
*/
int *ip;
char *pc = reinterpret_cast<char*>(ip);

在比特级别进行转换。将一个指针转换成一个整数，也可以把一个整数转换成一个指针，只能将32bit实例转换成指针

int doSomething(){
    return 0;
}

typedef void (*FuncPtr)();//FuncPtr一个函数指针，没有参数，返回值类型为void 
FuncPtr funcPtrArray[10];

funcPtrArray[0] = &doSomething;//编译错误：类型不匹配
funcPtrArray[0] = reinterpret_cast<FuncPtr>(&doSomething);//不同函数指针类型之间的转换

dynamic_cast

动态转换：转换成功，则返回类的指针或引用，失败则返回null

不能用于内置基本类型的强制转换
运行时进行类型安全检查

安全的基类和子类转换

上行转换时，动态转换和静态转换效果相同

下行转换时，动态转换具有类型检查功能，更安全
使用动态转换，基类中一定要有虚函数
相同基类不同子类之间的交叉转换，但结果是 NULL

class BaseClass{
	public:
    int num;
    virtual void fun(){};
};

class DerivedClass:public BaseClass{
	public:
    char *name[10];
    void bar(){};
};

//上行转换
BaseClass *pb = new DerivedClass();
//子类->父类，静态类型转换，正确但不推荐
DerivedClass *pb1 = static_cast<DerivedClass *>(pb);
//子类->父类，动态类型转换，正确
DerivedClass *pd2 = dynamic_cast<DerivedClass *>(pb); 

/*下行转换*/
BaseClass* pb2 =new BaseClass();
//父类->子类，静态类型转换，危险！访问子类name成员不存在
DerivedClass *pd21 = static_cast<DerivedClass *>(pb2); 
//父类->子类，动态类型转换，安全的。转换结果是NULL
DerivedClass *pd22 = dynamic_cast<DerivedClass *>(pb2);

I/O格式控制

操作符名	含义
dec	数值类型采用十进制表示
hex	数值类型采用十六进制表示
oct	数值类型采用八进制表示
ws	提取空白符
endl	插入换行符并刷新流
ends	插入空字符
setw(int)	设置域宽
setprecision(int)	设置浮点数小数位数(包含小数点)

cout << setw(5) << setprecision(3) << 3.1415 << endl;
//设置域宽为5，小数点后保留两位有效小数

CPU所执行的指令并不对操作数的类型加以区分，对各个操作数都执行相同的操作，编译器根据变量的数据类型选择合适的指令

符号扩展：有符号数据类型，用符号位扩展
0扩展：无符号数据类型，用0填充

函数

基本结构

/*求x的n次方*/
# include<iostream>

using namespace std;

double mypower(int x,int n){
    double val = 1.0;
    
    while(n--)
		val *= x;
    return val;
}

int main(){
    int x,n;
    
    cin >> x >> n;
    cout << x << "的" << n << "次幂是:" << mypower(x,n) << endl;
    
    return 0;
}

/*二进制转十进制*/
# include<iostream>

using namespace std;

/*x的n次幂*/
double power(int x,int n){
    double val = 1.0;
    
    while(n--)
        val *= x;
    
    return val;
}

int main(){
	int val = 0;
    char ch;
    
    /*每8位为一组*/
    for(int i = 8;i >= 0;--i){
        cin >> ch;
        if('1' == ch)
            val += static_cast<int>(power(2,i));
    }
    
    return 0;
}

随机数

/*随机数的获取*/
# include<iostream>
# include<cstdlib>

using namespace std;

enum GameStatus{WIN,LOSE,PLAYING};

/*产生结果*/
int rollDice(){
    int die1 = 1 + rand()%6;
    int die2 = 1 + rand()%6;
    
    cout << "payer rolled" << die1 << "+" << die2 << "=" << die1 + die2 << endl;
    
    return die1 + die2;
}

int main(){
    int sum,myPoint;
    GameStatus status;
    
    unsigned seed;
    cin >> seed;//输入随机数种子，即为随机数序列设置初值，不同初值，产生的随机数序列不同
    srand(seed);//产生随机数序列
    
    sum = rollDice();
    switch(sum){
        case 7:
        case 11:
            status = WIN;
            break;
        case 2:
        case 3:
        case 12:
            status = LOSE;
            break;
        default:
        	status = PLAYING;
        	myPoint = sum;
            cout << "point is" << sum << endl;
    }
    
    while(PLAYING == status){
		sum = rollDice();
        if(sum == myPoint)
            status == WIN;
        else if(7 == sum)
            status == LOSE;
    }
    
    if(WIN == status)
        cout << "You win" << endl;
    else
        cout << "You lose" << endl;
    
    
    return 0;
}

数学函数

$\begin{aligned} sin(x) = x+\frac{x^3}{3!}+\frac{x^5}{5!}+...+\frac{x^{2n-1}}{(2n-1)!} \end{aligned}$

# include<iostream>
# include<cmath>

using namespace std;

const double TINY_VALUE = 1e-10;

double tsin(double x){
    double g = 0;
    double t = x;
    int n = 1;
    
    do{
        g += t;
        n++;
        t = -t*x*x/(2*n-1)/(2*n-1);
    }while(fabs(t) >= TINY_VALUE);//涉及精确度，添加精度变量
    
    return g;
}

递归

# include<iostream>

using namespacce std;

int c(int n,int k){
    if(k > n)
        return 0;
    else if(n == k || k == 0)
        return 1;
    else
        return c(n-1,k)+c(n-1,k-1);
}

int main(){
    int n,k;
    
    cin >> n >> k;
    cout << "C(n,k)" << c(n,k) << endl;
    
    return 0;
}

引用形参

一个变量的别名，指向同一块内存空间

声明引用时，必须对他初始化，使他指向已存在的对象

只能初始化，不能修改

在作为函数参数时：执行主调函数中的调用时才会为变量分配内存，同时用实参来初始化形参

内联函数

内联函数不在调用时发生控制转移，只是将代码嵌入到调用处

适用于功能简单，规模小，经常使用的函数

inline 数据类型 函数名(形参列表){
    /*函数体*/
}

带默认形参的函数

在函数声明时，声明默认值

带默认形参值的形参必须在参数列表的最后

不允许对同于函数的形参多次定义，默认形参只能声明一次，声明时初始化，定义是不需要再次初始化的

函数重载

两个以上的函数，具有相同的函数名，但是形参个数或数据类型不同，编译器根据不同的参数列表调用最佳匹配函数

构造函数可以重载，析构函数不能重载

在C标准中

求整数的绝对值 abs() 和 labs() 应该包含 stdlib.h
求浮点数的绝对值 fabs() 应该包含 math.h

在C++标准中

stdlib.h：

int abs(int n);

long int abs(long int n);
math.h:

double abs(int n);

float abs(float x);

long double abs(long double x);

C++类型转换与函数