C/C++学习笔记（一）变量、过程化语句结构、函数

 

变量

数据类型

C/C++中的基本数据类型如下图所示，其中所占用空间会随着不同的硬件平台而有所改变，但是基本也是可以说明一些问题的了。

C/C++中的基本数据类型和java中的定义有所不同，java中的基本数据类型有也有四类但只有八种，如下所示，当然不同的硬件屏台也是有可能有不同的最大最小值的：

第一种是布尔型

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

第二种是整形

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

第三种是浮点型

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

 

第四种是字符型

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

 

变量和常量

基本类型的变量定义C/C++和java是基本相同的，语法格式：变量数据类型 变量名1[，变量名2......];例如

int a;
int b,c;
int d=0;
int e=1,g=3;

另外与变量相对应的是常量，在java中常量是由final定义，而在C/c++中是由const定义，常量一旦定义赋值就不能改变，语法格式：const 常量数据类型 常量名=数值常量；

const double PI=3.1415926;

其中数值常量也是常量，例如int a=2；表达式中2就是数值常量。

至于变量和常量的数学运算（加+，减-，乘*，除/，取余%）、关系运算、逻辑运算、赋值运算、++、--等等一些个运算就不必多说了，基础的基础。

 

 

过程化语句结构

结构化语句的语法C/C++和java基本一致，会其一就会其二。

1、条件语句

if(){

}

if(){

}else{

}

if(){

}else if(){

}else{

}

有一个三目运算符不得不说‘？’，称为条件操作符，语法格式：

（条件表达式）？（条件为真时的表达式）：（条件为假时的表达式）；

例如a>=b?a:b;意思是如果a>=b成立则返回a，否则返回b

2、switch

语法格式：

switch(表达式){

     case  常量表达式:{

              语句块

               break;

      }

      default{

             break;

       }

}

注意：1、任一两个case后的常量不能相等

2、如果case中没有break；则运行完当前case，就会继续运行下一case，指导遇到break；或者整个switch全部结束

3、default写在中间跟写在最后的效果一致

switch的数据类型

Java

1. byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持）都可以用于switch语句。

2. long、float、double、boolean四种基本类型以及它们的包装类（在Java所有版本中）都不能用于switch语句。

3. enum类型，即枚举类型可以用于switch语句，但是要在Java5.0（1.5）版本以上才支持。

4. 所有类型的对象（包括String类，但在Java5.0/1.5以上版本中，该项要排除byte、char、short、int四种基本类型对应的包装类）都不能用于switch语句。

C++

1. char、short、int、long、bool五种基本类型都可以用于switch语句。

2. float、double都不能用于switch语句。

3. enum类型，即枚举类型可以用于switch语句。

4. 所有类型的对象都不能用于switch语句。

 

3、当循环while

while(条件){

        语句块；

}

只要条件语句返回的是真值，则while循环就会开始新的一轮的语句块的执行，一直到条件语句返回假，或者遇到break语句。

do

    语句块；

while(条件)；

与上一种循环形式步同，do....while循环首先执行语句块，然后再判断，所以此形式的最大特点是至少会执行一次语句块。

4、for循环

for(int i=0;i<10;i++){

    cout<

}

for循环的特点是能够比较明确的知道循环几次。

for循环的执行过程：

int i=0；

判断i<10；的真假

如果为真则cout<

执行i++；

以此循环

 

以上是所有编程语言都应该具备的过程化语句，因为过程化语句是程序的骨骼，有了它们基本上可以解决世界上所有的逻辑问题。

 

函数

习惯上java中把函数称为方法，函数其实就是实现某项功能的方法，其目的就是要解决某个指定的问题。

我们在#include摸个头文件的时候其实已经把头文件里的函数包含进来了。比如math.h文件就包含了

void sin（double a）；计算正弦值

void cos（double a）；计算余弦值

void tan（double a）；计算正切值

void sqrt（double a）；计算平方根值

void abs（double a）；计算绝对值

 

创建自己的函数

首先必须告诉计算器自己编写了一个函数，其实就是函数的声明（declaration）

其次需要告诉计算器这几个函数式干什么的以及时怎么工作的，也就是函数的定义（definition）

函数的声明、定义、调用、return、重载等都在下面的代买中做了说明：

#include "stdafx.h"
#include 
using namespace std;
//函数声明
void  test(void);//无参数 无返回值
int mabs(int a);//函数名相同，但参数的数量，类型，排序不尽相同的现象叫做函数的重载
float mabs(float a);//a被称为形参
double mabs(double a);
void preValue(int n=100);//函数声明中定义默认的形参
int _tmain(int argc, _TCHAR* argv[])
{
//不管main函数在哪里定义，程序都从它开始，而且他有且只有一个，所以没有必要声明原型了
//ANSIC标准推荐main函数返回int型，以此来告知系统程序运行的结果，返回0表示正常结束，否则一场结束
 test();
 int n=5;
 preValue();//默认传给形参的实参为100
 preValue(n);//非默认时传递的实参为n的值5
 getchar();
 return 0;
}
//函数定义（实现）
void  test(void){
 int a1=5,a2=-5;//同一函数内部的变量名不同
 float b1=2.5f,b2=-2.5;
 double c1=3e-3,c2=-0.3e2;
 
 cout<<"a1="<=0?a:-a);//return表示结束函数，同时将后面表达式的值作为函数的返回值返回
}
float mabs(float a){
 cout<<"in="<=0?a:-a);
}
double mabs(double a){
 cout<<"in="<=0?a:-a);
}
void preValue(int n){
 cout<

上面代码中提到了函数的重载和预置默认参数，对于预置默认参数有以下规则：

另外，重载和预置默认参数容易产生混淆：

int fct(int a);
int fct(int a,int b=2);
int fct(int a,int b=3,int c=5);

上面三个函数式合法的，却是不合理的，主要是在调用的时候fct(1);可以同时匹配三个函数，由于电脑无法确定到底执行那一个函数，所以会导致错误。

所以同时使用重载和预置默认参数容易产生混淆，一定注意。

 

引用

函数是将实参的值赋给了形参，在函数中改变的是形参的值，而原来的实参是不变的。

// ConsoleApplication3.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include 
using namespace std;

void change(int a);
void change(int a){
	a++;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int a=5;
	cout<

上面代码的两次输出都是5，所以没有改变原来的实参的值。但是如果修改代买，在参数列表里用&符号引用实参后，再运行，输出的第一次是5，第二次为6

void change(int &a);
void change(int &a){
	a++;
}

这就是传说中的引用，语法格式：变量数据类型 &引用名=已声明的变量名（被引用者）;

对引用的操作如同对被引用变量的操作。

	int c=6;
	int &d=c;

上面的代码引用时d，被引用是c，这时c++;和b++;的效果一样，运算后所指向的数值也一样。

至于函数的实参和形参之间的关系，非常复杂，还牵扯到指针，以后会给出分析的。

java和C++在实参和形参之间的关系上也有不同之处，以后也会一并给出分析，到那时候你会明白为什么C++要比java难学了。

 

递归

函数可以嵌套调用，也可以递归调用，嵌套是调用其它的函数，递归是自己调用自己。嵌套调用前面的实例中已有说明，现在主要探讨一下递归：

int ftn(int n);
int ftn(int n){
	if(n==1){
		return 1;
	}else{
		return 2*ftn(n-1)+3;
	}
}

上面函数其实就是实现了数列的递推公式：f（n）=2*f（n-1）+3；