黑马程序员－－ios基础－－c语言－－基础语法、基本运算

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 

关键字

1.什么是关键字

• 关键字就是c语言提供的有特殊含义的符号，也叫“保留字”
• c语言义工提供了32个关键字，这些关键字都被c语言赋予了特殊含义

2.关键字的特征

• 全部都是小写
• 在开发工具或者职能文本编辑工具中会显示特殊颜色。默认情况下，c语言中的所有关键字在Xcode中都会显示紫褐色

3.main函数中哪些事关键字：

• int 、return

标识符

1.什么是标识符

• 标识符就是在程序中自定义的一些符号和名称。要跟关键字区分开来：关键字是c语言默认提供的符号，标识符是程序员自定义的

2.标识符的作用

• 标识符，从字面上理解就是用来表示某些东西的符号，标识的目的就是为了将这些东西区分开来
• 其实，标识符的作用就跟人类的名字差不多，为了区分每个人，就在每个人出生的时候起了个名字
• c语言是由函数构成的，一个c程序中可能会有多个函数，为了区分这些函数，就给每一个函数都起了个名称。变量的名称也是标识符

3.命名

命名规则（一定要遵守）

• 只能由26个英文字母的大小写、十个阿拉伯数字0－9、下划线_组成
• 严格区分大小写，test和 Test时两个不同的标识符
• 不能以数字开头
• 不可以使用关键字为标识符

命名规范（最好遵守）

• 尽量起个有意义的名称，比如一个完整的英文单词，别人一看这个名称就能了解这个标识符的作用
• 如果标识符中含有多个单词，可以使用驼峰标识：firstName、myFirstName,或者使用下划线_来连接：first_namemy_first_name

常量

1.什么是常量

常量，表示一些固定的数据

2.常量的分类

整形常量（int）

• 包括了所有的整数，比如2、103、－12、0等

浮点型常量（float\double)

浮点型常量分为double和float两种数据类型

• double:双精度浮点型，其实就是小数。比如5.43、－2.2、0.0等
• float:单精度浮点型，也是小数，比double的精确度低。为了跟double区分开来，fooat型数据都是以f结尾的，比如5.43f

字符常量（char)

• 将一个数字、英文字母或者其他符号（＋、－、！、？等）用单引号括起来，这样构成的就是字符常量。比如‘5’、‘¥’等。

字符串常量

• 将一个或者多个字符用双引号（“ “）括起来，这样构成的就是字符串常量。比如”4“、”女“、”5fs“。

变量

什么是变量

当一个数据的值需要经常改变或者不确定时，就应该用变量来表示。

定义变量

1.目的

• 任何变量在使用之前，必须先进行定义
• 定义变量的目的是：在内存中分配一块存储空间给变量，方便以后存储数据。
• 如果定义了多个变量，就会为这多个变量分别分配不同的存储空间。

2.格式

变量类型 变量名：

比如 int num;

• 变量名属于标示符
• 变量类型
• 不同类型的变量占用不同大小的存储空间。内存及其有限，分配适当的存储空间
• 约束变量所存放的数据类型（方便运算）

变量的使用

1.赋值

往变量里面存东西，就是赋值。赋值语句后带个分号；

第一次赋值，可以称为初始化

初始化的两种形式

先定义，后初始化：int a;a = 10;

定义的同时进行初始化：int a = 10;

2.修改

可以修改变量的值，多次赋值。每次赋值都会覆盖原来的值

使用printf输出一个、多个变量的值

 int a = 200;
 printf("%i", a);

double\float\char的输出，格式符的一些小技巧

常用格式符：%d\%i 整数（int) %f小数（float、double） %c字符（char)

   int score = 205;
    // 1:15
    int time = 75;
    
    int bestScore = 3161;
    
    // %d\%i是一个格式符（占位符），只能输出整数
    printf("分数是%d\n", score);
    
    
    float height = 1.78f;
    
    // %f用来输出小数，默认是6位小数
    printf("身高是%.2f\n", height);
    
    
    char scoreGrade = 'D';
    printf("积分等级是%c\n", scoreGrade);
    
    
    printf("分数是%d，身高是%f，等级是%c\n", score, height, 'C');

简单的加减操作

没有初始化时不要拿来使用

3.变量之间值的传递

可以将一个变量的值赋值给另一个变量

连续赋值

    b = a = 40;

4.常见错误

变量名相同

变量的作用域不对:变量的作用域指从定义变量的那行开始，一直到所在的代码块结束；代码块的作用是基石回收不再使用的变量，为了提升性能。

int test()
{
    int v = 10;
    return 0;
}

int main()
{
    {
        double height = 1.55;
        
        height = height + 1;
        
        printf("height=%f\n", height);
    }
    
   /*
    {
        int a = 10;
    }
    
    printf("a=%d\n", a);*/
    
    
    int score = 100;
    
    {
        int score = 200;
        
        {
            int score;
            score = 50;
        }
        
        printf("score=%d\n", score);
    }
    
    printf("score=%d\n", score);
    
    
    return 0;
}

利用第三方变量交换变量的值

 int temp = a;
 a = b;
 b = temp;

不利用第三方变量

 a = b - a;
 b = b - a;
 a = b + a;

变量的内存分析

内存寻址由大到小，优先分配存储地址比较大的字节给变量

变量越先定义，内存地址九越大

取得变量的地址：&变量名

输出地址：%p

一个变量一定先进行初始化，才能使用

int main()
{
    // 内存寻址由大到小
    int a = 10;
    
    int b = 20;
    
    int c;
    
    // &是一个地址运算符，取得变量的地址
    // %p用来输出地址
    // 0x7fff56f09bc8
    printf("a的地址是：%p\n", &a);
    // 0x7fff56f09bc4
    printf("b的地址是：%p\n", &b);
    // 0x7fff56f09bc0
    printf("c的地址是：%p\n", &c);
    
    //由于变量c没有经过初始化，所以直接拿来使用是不对的
    //int d = c  + 1;
    
    
    printf("c的值是%d\n", c);
    
    return 0;
}

scanf函数

scanf函数只接受变量的地址

int main()
{
    // 定义一个变量，用来保存用户输入的整数
    int number;
 
    scanf("%d", &number);
    
    printf("用户输入的值是%d\n", number);
    
    return 0;
}

算数运算符

算数运算符的基本使用

加减乘除：

    int a = 10 + 1 + 2 - 3 + 5;
    
    int b = -10;
    
    int c = 10 * b;
    
    int d = 10 / 2;

取余运算（模运算）：％两边都是整数，取余结果的正负性只跟％左边的数值有关

    int e = 10 % -3;
    printf("%d\n", e);

自动类型转换（double->int)

 int a = 10.8;

强制类型转换（double->int)

  int b = (int) 10.5;

自动类型提升

   double c = 10.6 + 6;

    double d = 1 / 3;
    
    double e = (double)3/2;
    
    printf("e的值是%f\n", e);

赋值运算符

“＝”

复合赋值运算符：

＋＝：

 a += 5; // a = a + 5;

*=:

  a *= 5; // a = a * 5;

自增自减

int main()
{
    /*
    int a = 10;
    
    a = a + 1; // 11
    
    a += 1; // 12
    
    a++; // 13
    
    ++a; // 14
    
    a--; // a -= 1;  a = a - 1;   13
    */
    // printf("a的值是%d\n", a);
    
    int b;
    int a = 10;
    // b = 10 + 12;
    //b = (a++) + (++a);
    
    // b = 11 + 11;
    b = (++a) + (a++);
    // a -> 11
    
    
    // a : 12
    printf("b=%d, a=%d\n", b, a);
    
    return 0;
}

sizeof

作用：用来计算一个变量或者一个常量、一种数据类型所占的内存字节数

基本形式

sizeof(变量\常量）sizeof变量\常量 sizeof（数据类型）

#include <stdio.h>

int main()
{
    //int size = sizeof(10);
    //int size = sizeof 10.9;
    
    int a = 10;
    
    //int size = sizeof(a);
    //int size = sizeof a;
    
    int size = sizeof(char);
    // int size = sizeof char; // 错误的
    
    printf("size=%d\n", size);
    
    return 0;
}

关系运算

1.条件判断

默认情况下，我们在程序中写的每一句正确代码都会被执行。但很多时候，我们想再某个条件成立的情况下才执行某一段代码

这种情况下可以使用条件语句来完成。先看一下基础知识，如何判断一个条件成不成立。

2.真假

• 在c语言中，条件成立为“真”，条件不成立为“假”，因此判断条件是否成立就是判断条件的真假。
• 任何非0值都为“真”，只有0才为“假”

3.关系比较

• 开发中经常要比较，利用关系运算符就可以比较两个值的大小。
• 关系运算符的运算结果只有2种：如果条件成立，结果就为1，也就是“真”；如果条件不成立，结果就为0，也就是“假”。

4.使用注意

• 关系运算符中==、!=的优先级相等，<、<=、>、>=的优先级相等，且前者的优先级低语后者：2==3>1
• 关系运算符的结合方向为“从左往右”：4>3>2
• 关系运算符的优先级小于算数运算符：3+4>8-2

#include <stdio.h>

int main()
{
    /*
    int a = 10;
    
    int b = 11;
    
    // 条件成立就返回1，真
    // 条件不成立就返回0，假
    int result = b >= a;
    
    printf("%d\n", result);
     */
    
    //int a = 2>3==1;
    //int a = 3+4 > 8-2;
    
    int a =  5 != 4 + 2 * 7 > 3 == 10;
    
    printf("%d\n", a);
    
    return 0;
}

逻辑运算

• 有时候可，我们需要在多个条件同时成立时才能执行某段代码，此时，我们就要借助于c语言提供的逻辑运算符
• 逻辑运算结果只有两个：“真”为1，“假”为0

1.逻辑与&&

使用格式

• ：“条件a&&条件b"

运算结果

• 只有当条件a和条件b都成立时，结果才为1，也就是“真”；其余情况的结果都为“0”，也就是“假”。因此，条件a或b只要有一个不成立，结果都为“0”，也就是“假”。

运算过程

总是先判断条件a是否成立

• 如果条件a成立，接着再判断b是否成立：如果b成立，“条件a&&条件b”的为1，即“真”，如果b不成立，结果就是“0”，即“假”
• 如果条件a不成立，就不会再去判断条件b是否成立：因为条件a已经不成立了，不管条件b如何，“条件a&&条件b”的结果肯定是“0”，也就是“假”

注意

• 逻辑与的结合方向是“自左至右”。

  
    // int a  =  10>3 && 7<6;
    
    //int a = 0 && 10;
    
    //printf("a=%d\n", a);
    
    /*
    int a = 10;
    int b = 10;
    
    //int c = (a>5) && (++b>=11);
    
    int c = (a<5) && (++b>=11);
    
    // a = 10
    // b = 10
    // c = 0
    printf("a=%d, b=%d, c=%d\n", a, b, c);*/

2.逻辑或||

使用格式

“条件a ||条件b"

运算结果

当条件a或条件b只要一个成立时（也包括条件a、b都成立），结果就是1，也就是”真“；只有当条件a和b都不成立时，结果才是”0“，也就是”假“

运算过程

如果条件a成立，就不会再去判断b是否成立，结果为”真“

如果条件a不成立，接着再判断b是否成立：如果b成立，”条件a || 条件b“的结果为1，即”真“，如果条件b不成粒，结果就是”假“

注意

c语言规定：任何非0的值都为”真“，只有0才是”假”。因此逻辑或也适用于数值。

    // 逻辑或 条件1 || 条件2
    
    //int a = 0 || 11;
    /*
    int a = 10;
    int b = 10;
    
    int c = (a<5) || (b++ - 10);
    
    // a = 10
    // b = 11
    // c = 0
    printf("a=%d, b=%d, c=%d\n", a, b, c);*/

3，逻辑非 !

使用格式

“!条件a"

运算结果

其实就是对条件a进行取反：若条件a成立，结果就是0；若条件不成立，结果就为1。

注意

可以连续多次使用逻辑非运算符：比如 !!(4>2)的结果是真。

4.优先级

逻辑运算符的优先级顺序为：小括号（）>符号－> ! >算数运算符>关系运算符>&&>||

    //int a = !(10>8);
    
    //int a = !-10;
    
    //int a = !10>8;
    
    /*
    int a = !!10;
    
    printf("a=%d\n", a);
    */

三目运算符

条件？ 数值1:数值2

代码笔记

#include <stdio.h>

int main()
{
    //计算2个整数之间的最大值
     int a = 10;
     
     int b = 99;
     
     int c = a>b ? a : b;
     
     printf("c is %d\n", c);
     
    
//    // 计算3个整数之间的最大值
//    int a = 10;
//    int b = 999999;
//    int c = 1000;
//    
//    // 求出a、b的最大值
//    int abMax = (a > b) ? a : b;
//    // 求出最终的最大值
//    int d = (abMax > c) ? abMax : c;
//    
//    //int d = (((a > b) ? a : b) > c) ? ((a > b) ? a : b) : c;
//    
//    printf("d is %d\n", d);
    return 0;
}