int *a=new int;
int *a = new int(5); 作用同上,但是同时将整数空间赋值为5
int *a=new int [5];

//字符串数组，只能在定义的时候，通过=赋初值，如果先定义，在赋值就不可以
{
    1. 定义的时候直接用字符串赋值
    char a[10]="hello";
//注意：不能先定义再给它赋值，如char a[10]; a[10]="hello";这样是错误的。
    2. 对数组中字符逐个赋值
    char a[10]={'h','e','l','l','o'};
//字符串可以赋值给字符指针变量，或者将字符串用字符数组保存。
    3. 先定义，后利用strcpy赋值
  char a[10];
  strcpy(a, "hello");
//strcpy是一种C语言的标准库函数，strcpy把含有'\0'结束符的字符串复制到另一个地址空间，返回值的类型为char*。
//函数实现还是通过数组一个个操作赋值。
}
//单字符赋值，可通过数组下标方式或指针方式，引用数组元素，进行
{
    char a[10];
  char ch='a';
  for(i=0;i<10;i++)
     a[i]=ch+i ; //可通过数组下标引用数组元素，完成赋值
  char *p;
  for(p=a; p<a+10; p++)
    *p=ch++; //通过指针对数组相应元素赋值
}

int a=15,x;
x=a<<2;//求x
a:00001111
a<<2:
00111100

char a=-4,b=4,x,y;
x=a>>2;
y=b>>2;
a:11111100(负数的补码形式不要忘)
a>>2:11111111,十进制为-1；

int y=-3456;
  printf("%8d\n",y);//1
  printf("%+8d\n",y);//2
  printf("%08d\n",y);
  printf("y=%-8d",y);
  printf("y=%-08d\n",y);  
//output
   -3456
   -3456
-0003456
y=-3456   y=-3456
//在devc++中跑完之后发现，这里添加1,2两句效果相同;期初我认为+是不是不起作用了，将y的数值改为正数可发现1式无+，2式有+
//最后两句都有4个空格

/*动态域宽设置*/
int i=1;
printf("##%*d\n",i,i);
i++;
printf("##%*d\n",i,i);
i++;
printf("##%*d",i,i);
//output
##1
## 2
##  3
/*注意这里的*不是指空格的数量，如其名动态域宽设置，设置的为其域宽，当i等于1时其宽度为1*/

//十六进制同理
  int y=123;
  printf("y=%8o\n",y);
  printf("%#8o",y);

short y=-1;
  printf("unsigned=%u",y);
//output
unsigned=4294967295;
//不难发现，负数在计算机内以补码形式存储，所以输出成无符号位的数字，需要把原先二进制转化为10进制

/*3.42 turb C 标准，16位微机中int=short=2byte */
  int x,y,z;
  long m;
  y=(x=32767,x-1);//逗号运算符从左往右
  z=m=0xffff;
//output
y=32766;
z=-1;
m=65535;
//int两个字节，16——>二进制（11111111），计算机中有符号表示为-1，如果int输出为%u，同样是65535；

printf("%f",1.12345678);
//实际输出为1.123457，因为保留6位有效数字，所以第七位要四舍五入到第六位。
printf("%.18f\n",1.12345678901234567890);
//下方实数末尾的f表示单精度浮点数，只存储7位有效数字
printf("%.18f\n",1.12345678901234567890f);

double a=1000000000; 
 double b=123.456; 
 printf("%e\n",a);
 printf("%f\n",a);
 printf("%g\n",a);
 printf("%e\n",b);
 printf("%f\n",b);
 printf("%g\n",b);

printf("\n*s1=%15s*","chinabeijing");
printf("\n*s21=%-5s*","chi");
//output
*s1=   chinabeijing*
*s21=chi  *
/*凡是设置了字符宽度，默认情况下就是右对齐，若前面有负号才改为左对齐*/

/*用法有三种，最易错的为%c*/
{
    char c1,c2,c3;
    scanf("%c%c%c",&c1,&c2,&c3);
}
//若此时输入a_b_c;
//output
a b
/*原因在于scanf会把空格当成字符进行存储*/

{
    float f;
    scanf("%f",&f);
    double b;
  scanf("%lf",&d);
}
/*float和double都会被转换成double然后送给printf函数 所以其实用%f还是%lf输出其实并不重要;
输入%lf表示地址对应的是8字节的double，%f表示地址对应的是4字节的float……存储方式都不一样，混用了肯定会出问题*/

{
    scanf("%d%*d%d",&a,&c);
    //计算机读入三个数，把第一个与第三个分别存入a和c
    //多了*表示读入但不赋值给变量
}

/*这个例子带你理解条件运算符从右到左是如何进行的*/
int a=1, b=3, c=2, d;
d = a>b ? a : c>b ? c : b; 
// 根据从右到左的结合顺序，则该表达式等价于d = (a>b ? a : (c>b ? c : b));
// 计算过程：
// 1、先算a>b，结果为0;
// 2、再算(c>b ? c : b)，之后算c>b，结果为0，
// 3、所以最后结果为b的值，也即等于3
// 如果是从左到右的结合顺序，那么该表达式等价于d =((a>b ? a : c>b) ? c : b);
//计算过程：
// 1、先算a>b，结果为0；
// 2、再算c>b，结果为0；
// 3、所以d=b，结果为b的值，也即等于3

//无参类型
void main() //类型标识符 函数名
{
}

//有参函数形式1
int max(int a,int b)//(类型名 形参)
{
    int z;
    z=a-b;
    return (z);
}
//有参函数形式2
int max(a,b) //(形参1，形参2)
int a,b;  //形参类型说明
{
    int z;
    z=a-b;
    return (z);
}

//空函数定义形式
int dummy
{
}

//交换两个数的一些好方法（不通过函数）
//方法1：使用一个临时变量来进行保存
{
    temp = a;
    a = b;
    b = temp;
}
//方法2：使用加减法来进行交换，这种方法实际上就是先把a+b的结果暂时先保存在变量a中，然后通过这改变后的a和原始的b进行减法就可以得到交换后的b，但是这种方法有一个缺陷，就是a和b都是int类型，a+b的结果可以越界。
{
    a = a + b;
    b = a - b;
    a = a - b;
}
//方法3：使用乘除法来进行交换，这种方法和方法2类似，只是用a*b代替a+b放在a中暂存，后面思路一样，这种方法有着和方法2一样的缺陷，就是越界问题，而且更加容易越界。
{
    a = a * b;
    b = a / b;
    a = a / b; 
}
//(妙)方法4：使用异或的方法来进行交换，这种方法不存在之前越界的缺陷，是一种很完美的方法，这种方法主要利用了异或的特性a^b的值先保存到a，因为a^b^b=a所以可以顺利完成交换。
{
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
}
//方法5：使用移位的方法，把原来的int类型的a，把a的值拆分成高16位和低16位，相当于多了16位的暂存空间可以周转，但是此方法的缺陷也显而易见，就是如果被赋值的a或者b超过了16位，这种方法就会发生错误。
{
    a <<= 16;
    a |= b;
    b = a >> 16;
    a = a & 0xffff;
}

int f(int a,int b)
{ 
  int c;
    if(a>b) c==1;
    else if(a==b) c=0;
    else c=-1;
    return (c);
}
int main()
{
    int i=2,p;
    p=f(i,++i);
    printf("%d",p);
}
//输出为0
int f(int a,int b)
{ 
  int c;
    if(a>b) c=1;
    else if(a==b) c=0;
    else c=-1;
    return (c);
}
int main()
{
    int i=2,p;
    p=f(i,i++);//改为i++
    printf("%d",p);
}
//输出为1

#include<stdio.h>
#include"math.h"
//两者的差异需知晓，如果使用下方形式，则先在当前源文件所在目录进行寻找

//三种形式
int fun;//无参
int fun(int,char,int);//有参数，只含参数类型
int fun(int a,char c,int b);//有参数，含参数类型和参数名

//递归调用求n!
int fac(int n)
{
  int f; 
    if(n==1||n==0) //递归的终结条件；
        f=1;
    else 
        f=n*fac(n-1);
    return f; 
}
int main() 
{
    printf("%d",fac(4));
    return 0;
}