黑马程序员技术交流社区

标题: 【昆哥的狗】+爱读书+爱书法+爱聊天+爱奇思幻想 [打印本页]
作者: 企业部-阿狗老师    时间: 2015-6-29 20:03
标题: 【昆哥的狗】+爱读书+爱书法+爱聊天+爱奇思幻想

   亲爱的黑马大家庭，你们好。很荣幸的由于缘分能在这个多元化的21世纪的我们相遇，相知。

开始的一知半解黑马的由来，到现在的相信黑马，  我只想说，我来了！黑马，你知道吗！
作者: 企业部-阿狗老师    时间: 2015-6-29 20:06
正如，我想说的是
一个人真的人生价值在哪里？
那就是做自己。

好多人都在碌碌无为的度过终生，这难道就是他们的命运吗？
看起来很简单的一件事，却真的很难实现。

就如你问你自己，你想要的是什么?你想做的是什么？

现实是残酷的，但是你有过残酷的面对吗？ 最后的结果是那么重要吗？

所以，我选择的编程，选择的iOS软件开发。

这是我想要的。
作者: 企业部-阿狗老师    时间: 2015-6-29 20:09
现在的我在自学iOS软件开发的基础——C语言。

从未接触的一种语言，对于我这种初学者来说是很枯燥单调的，但是人要有激情，要有兴趣。

要有一种倔强的情调。

所以我准备把每天看完视频做的一些笔记上传上来。  

分享，共勉。
作者: 企业部-阿狗老师    时间: 2015-6-29 20:10
2015.06.27


1、算式运算的类型转换

1）隐士类型转换（直接转换）
int——>直接转换成float 类型

2）显示类型转换（强制类型转换）
在所需要的类型前面添加所需要转换的格式。
如 小数类型需转换成整数类型
int main(){

float  f1=23.4f;
int  num = 10;
int sum = f1+num;
printf ("%d = sum,int(f1)\n"+num);
reture 0;
}

2、算式运算的类型转换的注意事项
1）大数加小数，应保持有效数字的格式，float的精确有效数字为7位。
2）显示类型转换只是临时转换，对于原有的数字还是保持原来的数字。


3、赋值运算符

表达式：  常量、变量及函数用符号链接起来的表达式，具有一定的意义。
表达式用分号结束。  1+1；
表达式的重点，  一点会有返还值。

赋值运算符的的定义  就是   =
  
赋值运算符的优先级为14级。
                   结合性为右结合。  自右向左。

如，   a=b=c=10;

不成存在  int a= b =c = 10的情况。

4、复合赋值运算符
        +=
         -=
         *=
         \=

    如  a+=b
     就是a=a+b  以此类推

5、自增自减运算符

分为  前缀自增自减 如++a  、  --a
        后缀自增自减     a++  、 a--

跟随自增自减运算连接的只能是变量a  不能为其他数或者表达式

   前缀自增自减运算符的算法  
    ++a     表达式的值为a+1     a的值为a+1  
                                            其实就是表达式的结果就是  a的值先变+1后用作用为表达式
                                                         简称  先变后用
  后缀自增自减运算符的算法
   a++     表达式为a的值         a的值为a+1
                                              其实就是表达式的结构就是a的值    而a的值+1
                                                           简称   先用后变


                                      但是不管怎么变化  a的值都+1

自增自减优先级   自增自减为二级。。  应提前计算
             结合性    自增自减应满足  右结合性  如  （a++）+（b++）+（c++）
                      先看变量，然后从加号的右边开始计算。
作者: 企业部-阿狗老师    时间: 2015-6-29 20:12
2015.06.28

1、sizeof 运算符的使用
sizeof 表示  计算 常量、变量在内存中所占的字节


sizeof（）；    不是一个函数


1）sizeof计算常量的方法
   sizeof (10);  计算一个int类型的常量10 在内存中所占的字符     //4
   sizeof (2.3f);  计算一个float 类型的常量2.3f 在内存中所占的字符   //4
   sizeof (2.3);   计算一个double 类型的常量 2.3在内存中所占的字符   //8
   sizeof(‘a’);   计算一个char  类型的常量 ‘a’在内存中所占的字符  //4


注意1、计算sizeof 常量字符的时候  所占内存的字符为  //4


2)sizeof计算变量的方法
    sizeof (a);  计算一个int类型的变量a 在内存中所占的字符     //4
   sizeof (2.3f);  计算一个float 类型的变量2.3f 在内存中所占的字符   //4
   sizeof (2.3);   计算一个double 类型的变量 2.3在内存中所占的字符   //8
   sizeof(‘a’);   计算一个char  类型的变量 ‘a’在内存中所占的字符  //1


计算sizeof 变量字符的时候  所占内存的字符为  //1


在sizeof 运算符计算 常量、变量的时候 （）可以省略。


3）sizeof 计算数据类型的方法
    sizeof (int);  计算一个int类型的数据在内存中所占的字符     //4
   sizeof (float);  计算一个float 类型的数据在内存中所占的字符   //4
   sizeof (double);   计算一个double 类型的数据在内存中所占的字符   //8
   sizeof(char);   计算一个char  类型的数据在内存中所占的字符  //1


在sizeof 计算数据类型的时候 （）不能省略。




2、逗号运算符。


逗号表达式：  多个表达式用逗号隔开的表达式为逗号表达式。
   a+b,b+c;


逗号表达式的算法；  依次算出每个表达式的结果，  以最后一个表达式的结果作为整个逗号表达式的结果。
    a+b,b+c,10           //10就是逗号表达式的结果


逗号表达式是可以嵌套使用的。


  (a+b,(b+c,b-c))   //逗号表达式的结果就为b-c的结构


逗号表达式有时候是用来简化代码，不需要结果，而重过程。


不是所有用逗号表示的都叫逗号表达式            //在定义多个变量用逗号隔开的时候，就不是逗号表达式。


//  int a = 1, b = 2, c = 3;  这就是不是一个逗号表达式。




3、关系运算符


C语言中所有的数据都有真假性，非零及真。


    关系运算符分为   
       >   
       <
       >=
       <=                      // 以上均为6级
       !=                      //         7级
       ==                       //        7级


  在关系运算符中 一个等于号叫赋值， 只有两个等号才叫等于。
关系运算符的作用是  用来比较两个数或者两个表达式的关系




关系表达式的值只有两种，非0及真  （1）
                        0就是假  （0）


关系表达式就是用关系运算符链接起来的表达式为关系表达式


用分号结束的关系表达式叫关系表达式语句


关系表达式的结合性为   左结合


关系表达式的运算过程。   应遵循所有数据中的关系，非零及真
作者: 企业部-阿狗老师    时间: 2015-6-29 23:42
今晚把运算符都看完了。

把已看完视频总结的笔记记录下来。

1、逻辑运算符

     分为   与 &&
            或丨丨
            非 ！

   逻辑表达式   就是用逻辑运算符连接起来的表达式叫做逻辑表达式

   逻辑表达式的值    也分为两种  非零及真 // 0 1


   && 的优先级为   // 11级     结合性为  左结合
   丨丨的优先级为  // 12级               左结合
    ！的优先级的   // 2级                右结合    (！(！(！a)))

有关  &&  运算的结果为  同真为真  一假为假
      丨丨              一真为真   同假为假
       ！               真变假    假变真


有关逻辑运算符的短路问题

&&  一假为假  
A&&B   A为假 ， B就不会执行

丨丨   一真为真   
A丨丨B   A为真，B就不会执行


int a = 2，b=3,c=4 result=-1；
      //   
  result= ++a&&++b丨丨++c；

printf("result = %d\n",result)              //1
printf("a = %d,b=%d,c=%d\n",a,b,c)          // a = 0  b=0  c=1


二、三目运算符

具有三个操作数

三目运算符的表达式为      表达式1?表达式2:表达式3  ;
  
三目运算符的计算          表达式1为真的话   表达式2的值就作为整个三目运算符结果的返回值
                          表达式1为假的话   表达式3的值就作为整个三目运算符结果的返回值  

对于三目运算符的结合性 为右结合

a?b:c?d:e   //  a?b:(c?d:e)
作者: cemabenteng    时间: 2015-6-29 23:45
你是黑马哪期的？
作者: 企业部-阿狗老师    时间: 2015-6-29 23:50
cemabenteng 发表于 2015-6-29 23:45
你是黑马哪期的？

我还没报班呢。
自学中
作者: cemabenteng    时间: 2015-6-30 21:53
昆哥的狗 发表于 2015-6-29 23:50
我还没报班呢。
自学中

把视频至少看一遍再来
作者: 企业部-阿狗老师    时间: 2015-6-30 23:37
cemabenteng 发表于 2015-6-30 21:53
把视频至少看一遍再来

  正在看呢。  一边看一边学习吧，夯实基础，才能为以后的道路铺平更多的障碍。
作者: 企业部-阿狗老师    时间: 2015-6-30 23:38
今晚看到了
第四天。

程序的结构。  这个由于高中数学有所涉及。 看起来没多大问题。  占了5个小视频。  把所做的笔记分享出来吧。





/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


C语言中的程序结构


1、C语言中的程序程序结构

1）顺序结构
2）分支结构  =   条件结构
3）循环结构

又分为  1、while 循环语句  2、 Do while循环语句  3、for 循环语句


2、if 语句的介绍跟使用

if 语句是 分支语句的一部分


if的结构        if（表达式\常量\变量）{
                          语句块1；
                                  }
                         后续语句；

          判断小括号的值    1、  为真    执行语句块的内容
                            2、  为假    不执行语句块的内容


if。。。else  的结构

                if（表达式\常量\变量）{                //  表达式为真   执行语句块1
                          语句块1；
                                  }else{
                           语句块2         }           //   表达式为假  执行语句块2



             注意： 不论表达式为真还是假  都会执行一个语句块


补充：  有关if 结构的嵌套  

                if（表达式1）{
                      语句块1 ；                 //表达式1为真 直接执行语句块1
                        }  else  {
                        if（表达式2）{          //  表达式1为假  执行else里面的内容   
                        语句块2；                                       //   如果表达式2为真    则直接执行语句块2
                           }else{                                    
                          语句块3；                                     //   如果表达式2为假    则直接执行语句块3
                           }   
                        }
作者: 企业部-阿狗老师    时间: 2015-7-2 17:41
由于昨天出差。
坐车坐了6个小时。



记录的笔记没有发出来。

现在发出来。。。。

1、有关if语句的高级用法


             if（表达式1）{                                   //代码块1执行的话      表达式1为真
                     代码块1
                          } else if （表达式2）{              //代码块2执行的话   表达式1为假   表达式2为真
                           代码块2
                                  }  else  if（表达式3）{
                                     代码块3                 //代码块3执行的话   表达式1、2为假  表达式3为真
                                             }  else{
                                        代码块4}            //代码块4执行的话   表达表达式1、2、3均为假




2、有关if语句的注意事项


1）有关空语句的使用      int a == 3
                      if（a>3）;     表示为空语句。   不执行语句。

2）不加大括号的if使用，直接运行下一句链接的语句    （如果if 后面只有一句话，可以直接省略大括号）
                       int a ==3
                            printf "正确\n";

3）有关永真跟永假的使用   
                    int（1）{   }    表示为永真
                    int（0）{   }    表示为永假
4）有关return 0的使用

                 在一个函数中，可以有多个return 0；的出现。
                              但是出现一个只会程序将终止。  不会再执行以后的代码内容。
作者: 企业部-阿狗老师    时间: 2015-7-4 09:36
1、有关switch语句的使用

  switch（表达式）{                      //先判断表达式1的内容。  然后对case里面的表达式进行比较，如果相同就执行对应语句
       case 常量表达式1：  语句1         //表达式等于表达式1    执行语句1
       case 常量表达式2：  语句2         //表达式等于表达式2    执行语句2
       case 常量表达式3：  语句3         //表达式等于表达式3    执行语句3
       case 常量表达式4：  语句4         //表达式等于表达式4    执行语句4


          default   语句5                //如果表达式跟case中的表达式都不相同 则执行default 中的语句
                          }               



          有关switch语句中的注意点。
1、case之后跟空格  用冒号隔开：   
2、有关case 的穿透问题。

         在一个switch语句中，  结束语句如果不用break链接，case会接着下一段case语句

                            所以有关case的穿透：   某个case语句执行完成后，并没有结束，而直接向下执行其他的case语句


避免case穿透     ：  我们需要在每一个case语句结束后，家伙是哪个一句话，  break；
      break  作用就是结束switch语句


2、  有关if与switch语句的转换问题。

      在分支结构语句中， if与switch是可以相互转换的。

          如果分类数据比较大且范围内容比较广，可以使用if语句
          如果判断内容比较少，if使用的代码量比较大  这时候可以使用switch 语句。
作者: 企业部-阿狗老师    时间: 2015-7-4 10:45
switch语句的注意补充事项

  格式：     switch（表达式）{
              case 常量表达式： 语句1；
                          break：
                         default  语句
                                }

1、有关switch表达式
    1）可以为整形常量   //  stitch（10）
    2）可以为整形变量   //  int a = 2；   switch（2）   
    3）可以为返回值为整形的表达式             // stitch（5+5）  
    4）可以为转换为int类型的表达式            //switch（‘a’）


case后面可以有多句语句。
case语句后面可以加括号，也可以不加括号。
case语句后面的语句可以加break也不可以不加break。



2、有关case语句表达式
    0）case后面的空格跟冒号不能省略
    1）可以是常量   //case 10：
    2）可以是常量表达式   //case 5+5：
    3）default 的位置可以随便放。  
    4）case语句的穿透同意适应于default
    5）default 如果放到switch语句最后可以不加break；  。  但是不是最后必须要加上braek；
    6）case后面不能是小数
    7）case语句后的默认的第一句话不能定义变量。 // 如果非要定义变量的话 必须要加上大括号。  第二句可以定义变量
    8)编译器的BUG   
作者: 企业部-阿狗老师    时间: 2015-7-4 23:50
循环结构。


循环结构就是   在结构语句中有一部门符合循环控制条件，在某一部分重复执行代码块，我们把这样的结构叫做循环结构。

循环结构的组成    1）循环控制条件
                  2）循环体
                  3）循环控制条件为假的控制


1、有关while循环结构的表示

  while（表达式）{
         语句块1；
                }

               

  while循环的一个陷阱：就是一直执行循环体中的代码 不会退出。
作者: 企业部-阿狗老师    时间: 2015-7-5 22:22
有关   do while的结构表示方法
    do{
         语句1 ；                               //循环体
         语句2；
               }
        while（条件）；


  do while是一个直到型循环，而while是一个当型循环。


注意：
1）do while 不论循环控制条件是否为真，循环体最少执行一次。
作者: 企业部-阿狗老师    时间: 2015-7-6 22:32
有关for循环结构
1、for 循环结构的表示方法

   for（表达式1；表达式2；表达式3）{
                          语句             //循环体
                                    }   //表达式1为定义变量，表达式2为循环控制条件，循环3为中止循环控制条件


  一般是    表达式2->循环体->表达式3  ->表达式2.。。。。。。


2、表达式1、表达式2，表达式3  均可省略。

3、         有关for循环的死循环为  for（；；）{
                                               }  //为for循环的死循环。

4、  有关for循环的空语句   for（表达式1；表达式2；表达式3）；


5、for循环的镶嵌   
              for（表达式1；表达式2；表达式3）{
                      for（表达式4；表达式5；表达式6）
                                                }

7、for循环镶嵌的应用。
1）打印星型矩形     
* * * * * *
* * * * * *
* * * * * *
* * * * * *
* * * * * *
* * * * * *                   for(int i=0;i<6;i++){
                                  for(int j=0;j<6;j++)

                                        printf("* ");
                                                    }

2)打印正三角形
*
* *
* * *
* * * *
* * * * *
* * * * * *                   for(int i=0;i<6;i++){
                                   for(int j=0;j<i;j++)
                                            printf("* ");
                                                      }
3)打印倒三角形
* * * * * *
* * * * *
* * * *
* * *
* *
*                              for(int i=0;i<6;i++){
                                   for(int j=0;j<6-i;j++)
                                            printf("* ");
                                                      }
打印9*9乘法表        
1×1=1  
1×2=2 2×2=4  
1×3=3 2×3=6 3×3=9  
1×4=4 2×4=8 3×4=12 4×4=16  
1×5=5 2×5=10 3×5=15 4×5=20 5×5=25  
1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36  
1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49  
1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64  
1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81                                
                                                                       for(int i=1;i<=9;i++){
                                                                           for(int j=1;j<i;j++)
                                                                              printf("%d*%d=%d",i,j,i*j );
                                                                                           }

3、break语句的使用

               break语句是跳出循环或者是结束循环。

4、continue语句的使用。

                 continue语句是结束本次循环，继续下一次循环。   能加快for循环语句。
作者: 企业部-阿狗老师    时间: 2015-7-7 23:19
C语言是由函数组成的                              在C语言中，函数是一个面对过程的。
   函数就是独立功能的代码段组合而成的。


有关自定义函数的写法。

   返回值类型  函数名（参数）{

                         函数体；  
                              }

1）无参无返回值函数
            void （）{
                             }


2）无参有返回值函数
           
例子：    int print（）{
                            }     


注意：  有返回值的情况下，函数体中一定会有return  语句。

3）有参无返回值函数

          void print（int n）{                       //参数的话也叫形式参数表列  简称形参            
                                  }                            对于形参的表示方法为  数据类型 变量名

4）有参有返回值的函数
例子：    int sum（int x，inty）{
                                  }



有关函数中的参数
1、可以分为形式参数跟实际参数

形式参数简称为形参       一般为定义函数  函数名后面的小括号内。
实际参数简称为实参       一般为主调函数  函数名后面的小括号内。

2、实参可以为变量、常量、表达式及函数。

3、
1）形参定义后并不会立即分配存储空间  在函数调用的时候才能真正分配到存储空间
2）如果有多个形参，可以用逗号分隔
3）形参的类型可以不相同
4）在函数中不能定义和形参相同的变量

4、主调函数：

    void test1（）{
                    }

    void test2（）{
         void test1（）
                      }


   void  test2  就为主调函数，  void test1 就是被调函数
     //在主调函数中的参数就是实际参数     在被调函数中的参数就是形式参数

5、有关参数的传递过程

   1）调用函数的时候，实参的值是一个确定的值
   2）把实参的值，赋值给形参
   3）形参跟实参的个数、类型要一致
          如果类型不一致，会造成精度丢失
   4）形参的值在函数内部可以被修改，但是不影响主调函数中实参的数据。
作者: 安3520    时间: 2015-7-8 00:08
点点滴滴到底
作者: 企业部-阿狗老师    时间: 2015-7-9 00:31
今天把函数的内容简单的大概看了一遍。  当然还是有看不懂的需要不断的磨合。
同时希望在接下来的日里能好好吃透视频上讲解的一些内容。

本章的知识点都是打基础的，还是需要多加练习很巩固。关于Xcode 的使用 由于没有实机操作，就是很快的过了一遍。希望尽快的看完基础课能有机会来黑马努力学习吧！
作者: 企业部-阿狗老师    时间: 2015-7-9 00:34
1、有关函数的返回值及注意事项

            函数的返回值：被调函数返回给主调函数的值
1） 有关函数的返回值  一定会有关键词return；
2）  return后面可以为常量、变量、或者表达式。可以加上括号 也可以省略。
3） 如果return的值和函数定义的类型不一样，以函数的返回值类型为准。


2、有关函数的声明
1）函数的使用流程
          先声明------>  定义  --------->调用

  函数的声明：告诉编译器这个函数已经存在了，告诉编辑器被调函数的返回值类型，以便在主调函数中处理被调函数返回的数据。

2）声明的格式：把被调函数的头部拷贝一份加上一个分号；

注意：1、如果被调函数的返回值是int类型，此时可以不用声明
      2、如果被调函数写在主调函数之前，此时可以不用声明。

3、递归函数

   在函数内部存在调用当前函数本身的语句，这个函数就是递归函数。

递归调用：递归函数中，调用自己的操作，就叫做递归调用。

注意：  1、主调函数就是被调函数
        2、在递归函数中应该存在能够让递归结束的条件。


构成递归的条件：
   1、递归函数的自我调用，自己调用自己
   2、存在一个条件，能够让递归结束（否则，就是死循环）
   3、找到一个规律，让要解决的问题的规模缩小

递归的阶段：
1）递推阶段


2）回归迭代阶段
作者: ringxxx    时间: 2015-7-9 00:57
蛮拼的。。。哎
作者: 企业部-阿狗老师    时间: 2015-7-9 23:54
ringxxx 发表于 2015-7-9 00:57
蛮拼的。。。哎

看似 很拼。  其实每天都是花很少的时间来干的，  还有很多的不懂很不理解。
作者: 企业部-阿狗老师    时间: 2015-7-10 00:11
1、有关include的使用
#include  是一个预处理指令


作用是： 把要包含的文件的内容拷贝到当前书写 include的地方。

#include  表指令  ， 包含文件

#include"  "包含自定义文件

搜索的顺序：   ------>当前目录----->编译器目录------>找系统目录----->报错


当前目录：  和 main.c文件同一个文件夹下面。



若果改变了编译器的include的自定义文件后，运行后发现没有改变


破发：
   1）清空缓存    product-->clean
   2）手动清理



2、有关模块化编程的概念

     把功能相似的函数封装到不同的文件中

实现：
    .c  C语言的源文件
    .h  （header）头文件

       1）方法的声明   但是不能实现方法
       2）声明变量
       3）声明结构体

好处：  用的时候，只需要把.h文件，对外隐藏源文件的实现
        团队的分工跟协作
        可以吧工程细化分若干个模块
作者: 企业部-阿狗老师    时间: 2015-7-11 00:14
今天学习的是进制问题。


感觉不错。。。。希望继续努力！


PS
————————————————————————————————————————————
1、进制转换

1)二进制转换为十进制

采用的是位权相加

位权==数码乘以基数的位数方

0  0  1  0

0*2^0+1*2^1+0*2^2+0*2^3 =2

2)十进制转换为二进制则采用的是
除二取余  然后再倒叙的方法。

3）二进制转换为十六进制
采取的是4合一的方法

0010  1011  0010. 1111
   2      B      2  .F=2B2.F


整数部分 采取从右往左的方法取数，  小数部分采用从左往右取数。 位数不足补零

4）十六进制转为为二进制采取的是 一拆四

同理：整数部分 采取从右往左的方法取数，  小数部分采用从左往右取数。 位数不足补零

2     B   2     .F
0010      1011    0010       1111



计算机中用来存取数据的是补码

有关原码、反码、以及补码的概念及转换

源码
   一个数绝对值的二进制表示，  如果是+  最高位（最左侧的位）  改为0
                                     -  最高位（最左侧的位）  改为1

反码：

   正：正数的反码等于原码
   负：除符号位不变，其他位逐位取反  （1-->0,0--->1)

补码：
   
  正：正数的补码等于原码

  负：  
              1）反码+1
              2）在原码基础上符号位不变，其他位取反。
作者: 企业部-阿狗老师    时间: 2015-7-12 22:58
1、为什么要引入补码概念
              计算机能够做减法，减法的电路设计更简单

运算符：
        运算符是用来连接操作数，组成有意义的式子

分类：
      算术    关系   逻辑    位运算

位运算

     用来整数的二进制位之间的运算

  &   按位与  //如果两个位进行&操作，同1则结果为1，有0结果就为0
  |   按位或    //如果两个位进行|操作，有1则结果为1，同0结果就为0

补码--->原码    ：  符号位不变，取反+1
  ~   按位取反   //1变0  0变1
  ^   按位异或   //相同为0  不同为1
  >>  右移位

  一个数右移n位，值等于 原值除以 2^n

右移位，移除去的部分要舍弃
      高位要补符号位

注意：右移位，不会改变一个数的正负性


  <<  左移位    左侧、高位移动出去的位就丢了  低位开始补0

            记忆的技巧：向左移动n位，相当于原数*2^n

注意：左移可能会改变一个数的正负性




2、有关变量地址的获取及存储原理
1）计算机分配内存的时候：从高地址向底地址分配，先定义的变量，分配的是搞地址
                                            后分配的变量，分配的是低地址

2）变量的存储细节：
//低字节  存放在低地址   高字节存放在高地址

3）变量的地址：变量的首地址（变量在内存中占用的存储单元中地址）


作者: 企业部-阿狗老师    时间: 2015-7-13 23:52
  整型变量修饰符
    改变整型变量占用的存储空间
     int  short  long  long long

  改变一个数的符号

   signed  unsigned


表示：原来最高位作标识一个数的正负，现在用来参加计算

   计算机默认的是一个有符号的数

无符号数用%u 来输出


char  型常量的存储问题

  sizeof（'a')
------>先找到'a'的ascii码值   97
------>  把97按照int类型进行转换
------>  把四个字节存储

ch='a'
------>97
------> 把97转换为  2进制     01100001  一个字节

总结：char类型的常量跟变量的存储方式是不一样的

0 - 127    用常见的字符ascii  码


c%输出一个字符，到ascii码表中找 ascii码值等他的字符


作者: 企业部-阿狗老师    时间: 2015-7-14 00:17
今天开始学习的是C中一个听大家说比较重要的内容——数组！

所以看的比较仔细。

看完之后，整理了一下笔记。！

不懂的时候可以好好回顾回顾！

一日三省吾身 每天做到一点三问！

学习之路，任重而道远。 努力前行，不离不弃！
作者: 企业部-阿狗老师    时间: 2015-7-14 00:18
1、数组：
  相同类型的若干个数组成的一个有序的集合

2、一维数组
      数组的每个元素都是基本数据类型的变量
      数据的每个元素都不是一个数组

3、 一维数组的定义

     数组类型  数组名[数组长度];

     int a[3];   //定义了一个int类型的数组，数组名是a，数组长度是3
                 //这个数组只能存放3个 int类型的数值

4、移位数组的定义的注意事项

1）数组的长度可以是一个常量，也可以是一个常量表达式
2）数组名的命名规则：严格按照标识符的命名规范
3）数组名不能和其他变量名同名
4）数组的长度不可以为一个变量
5）数组的长度可以使用  宏定义
6）定义数组的时候，还可以定义普通变量
int x，y，a[3];

5、有关数组的初始化
   给数组的每一个元素富裕一个初始值
数组的初始化方法：
1）定义的时候同时初始化

  格式：
  数据类型 数组名[长度] = {值，值...}；

   定义的同时安全初始化
   int a[3]={1,2,3};


   定义的同时进行部分初始化
   int a1[3]={1,2}

2)先定义数组，然后再初始化
   int a[3];
通过下标法进行初始化
    a[0]=1;  //给数组的第一个元素赋值1
    a[1]=2;  //给数组的第二个元素赋值2
    a[2]=3;  //给数组的第三个元素赋值3



有关数组初始化值得结论：
1、如果定义数组后，没有初始化，数组中是有值的，是随机的垃圾数，所以如果想要正确使用数组应该要进行初始化

2、对于数组来说，一旦有元素被初始化，其他元素都被赋值0

特别强调：使用先定义后初始化的方式，如果部分数组元素被初始化了，系统不会对没有初始化的那部分元素进行赋值=的操作


//数组中的每一个元素都是变量
int a[3];
  a[0]  代表就是数组的第一个空间


// 下标：数组元素的符号，数组的标号从0开始
一个长度为n的数组，  下标范围：0~n-1
数组的引用（访问）：数组名（下标）就可以访问数组的元素

如果要逐个的访问数组的元素话，这就叫数组的遍历


作者: 企业部-阿狗老师    时间: 2015-7-15 00:45
1、一维数组的地址
1）数组名代表了数组的首地址==数组的第一个元素的地址
//  x=&x[0]
// ca=&ca[0]

数组名是一个常量
2）数组中的两个元素的地址是连续的


2、数组的长度
//数组的总长度/数组的任何一个元素在内存中占用的字节数

len=sizeof(a)/sizeof(int);

3、一维数组的越界问题
int a[2]={1,2};
a[0]=1
a[1]=2

a[2]=3  //这就叫做一维数组的越界问题
数据有可能丢失

4、用数组元素作为函数参数（实参），传递的是值。
5、用数组名作为函数参数（行参），传递的是地址。

数组名作为函数参数的注意点：
1）形参数组的类型和长度要和实参一致

                                      //如果不一致，会造成错误
2）形参的数组的长度和实参的长度可以不一致，虽然不会报错，但是运行的结果跟实际不相符

3）形参数组的长度可以不用写。

4）关于数组名作为函数参数后，数组的长度信息丢失的问题

注意：C语言中规定，不管什么类型的数据，数据的内存地址在内存中占8个字节
作者: 企业部-阿狗老师    时间: 2015-7-16 00:56
1、冒泡排序（大数下沉)
1）比较相邻的元素，如果第一个比第二个大，就交换他们
2）对每一对相邻元素做同样的工资，从开始的第一队到结束的最后一对，在这一点，最后的元素应该会是最大的数
3）针对所有的元素从复以上的步骤，除了最后一个
4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

一般用表示方法：

   for（int i = 0;i<len-1,i++){

          for(int j = 0;j<len-1-i,j++)

                                }



2、选择排序
  选择排序是一种简单直观的排序算法，他的工作原理如下，首先在未排序序列中找到最小元素，存放到排序序列的起始位置，
然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾，以此类推，知道所有的元素排序完毕


一般的表示方法：  
    for(int i=0;i<len-1,i++){
     for(int j=i+1;j<len,j++)

                          }
3、折半查找思想
    在有序表中，去中间元素作为比较对象，若给定值与中间元素的要查找的数相等，则查找成功，若给定值小于中间元素的要查找的书，则
在中间元素的作伴去继续查找。
    若给定值大雨中间元素的要查找的数，则在中间元素的右半区继续查找，不断重复上述查找过程，指导查找成功，或所查找的区域无数据元素，查找失败


  定义一个初始值   low   跟  high   跟 mid    以及要查找的key值

    mid=（low+high)/2

  当key>a[mid]   low=mid+1    //在右半区查找

  当key<a[mid]   high=mid-1     //在左半区查找

  当key==a[mid]   mid 就是所要求查找的位置

  当low>high      返回查找失败信息


而要求插入一个数字  要求求其位子  则为  mid+1  位置数
作者: 企业部-阿狗老师    时间: 2015-7-17 23:22
1、二维数组：
    可以看做是一个特殊的一维数组，这个一维数组的每个元素又是一个一维数组
   二维数组的定义
        数据类型   数组名[第一维的长度(行)][第二维的长度(列)];

   int a[2][3];

  理解方法：
1）这是一个特殊的一维数组，一维数组有两个元素a[0] a[1]
           a[0] 它又存放了一个一维数组该数组长度为3

2) 定义了一个2行3列的一个矩阵

  //注意事项
    数组名不能跟变量名同名
   
    数组的长度可以是常量表达式

2、二维数组的初始化
  1）定义的同时初始化

   1、完全初始化
     int a[2][3]={{},{}}；  //分段
     int a[2][3]={1,2,3,4,5,6}  //连续赋值

   可以省略第一维

   2、部分初始化
      int a[2][3]={1}；  第一个元素为1  其他元素为0


   2）先定义，后初始化
       int a[2][3];
       a[0][0]=1;

3、二维数组的遍历

       定义一个数组  int a[2][3]={1,2,3,4,5,6}；
         for(int i=0;i<2,i++){
             for(int j=0;j<3,j++){
            printf("%d\t",a[i][j]);
                         }
           printf("\n");
           }

4、二维数组的存储细节
   数组的首地址==数组名==&a[0]=&a[0][0]

   通过数组名计算数组占用的总字节数
     len=sizeof(数组名)

   计算数组每一行占用的字节数
     len=sizeof(a[1]);

   每一行有多少列
    列数=行的总字节数/ 每个元素占用的字节（数组类型）
     sizeof(a[1])/sizeof(数组类型）


   
作者: 企业部-阿狗老师    时间: 2015-7-18 23:47
1、字符数组的定义：
1）一维字符组（用来存储字符的数组）定义
    char 数组名[数组长度]
      char ch[5];

2）二维字符数组的定义

      char arr[4][10];

2、字符数组初始化和引用

初始化

1）定义的同时进行初始化

            char ch[5]={'a','b','c'}
             char ch[]={'a','b','c'}

             char ch[5]={'a'}

2)先定义，后初始化

           char ch[3];
          ch[0]='a';
          ch[1]='b';
          ch[2]='c';

遍历  
    for(int i=0;i<3,i++){
          printf("%c",ch[i]
        }

3、字符数组是用来保存字符串的
   
    字符数组的作用：
  1）保存字符
  2）保存字符串

  第一种方法：char a[10]={"abcd"};

  第二种方法：char a[10]="abcd";




  
作者: 企业部-阿狗老师    时间: 2015-7-19 00:20
1、字符串的输出和输入
1）用%s输出一个字符串
2）从给定的地址开始，一直输出字符，直到遇到\0就停止了
3）%s接收键盘上输入的一个字符串，保存在str未首地址的字符数组中


注意点：
1、如果以%s格式进行输入的话，要注意空格问题
2、如果输入的字符串有空格，则空格之后的字符无法被接收保存
（以%s的格式输入，scanf遇到了空格，就结束了

输入的字符串的长度要小于数组的长度

2、字符串长度计算方法
  1）使用字符串函数
   strlen(str1);
  2)以'\0'作为条件，进行判断   遇到\0 就结束
  // \0之前的就是字符串的长度


3、字符串函数的使用
   puts(数组名)   输出一个字符串
   gets(数组名)   输入一个字符串



  需要包含 string.h 的头文件
   strcat()  连接一个字符串   把两个字符串连接成一个字符串
                              A B两个字符串
  strcat(A,B)  把字符串B连接到字符串A后面



  puts（字符数组地址）；
  1）puts函数可以自动换行
  2）也可以不是数组的首地址，可以是元素的地址
  3）必须是字符数组
  4）不可以格式化输出


  gets();
   使用gets会给出一个警告
  1）不安全：数组的长度是100，但是如果你输入了120个字符，存在越界问题
  2）使用gets可以接收空格


  strcat 函数介绍， 使用该函数必须要引入头文件
  
  1）格式：  strcat(oldStr,newStr);
  2)oldStr 的长度要足够到，只要能保存下oldStr+newStr
  3) newStr 把 oldStr的最后一个字符\0给覆盖了。


  strcpy  字符串拷贝函数

  strcpy(oldstr,newstr);
    把newstr拷贝到oldstr中，newstr会覆盖掉oldstr中的内容

  strcmp  字符串的比较函数
     strcmp(str1,str2);            //比较两个字符串的大小

               规则：比较字符的ascii码值  比较在字典中出现的顺序
  
  比较的过程： 逐个取两个字符串的字符对应位相比较，从第一位不相同的位开始，逐个确定字符串大小

  strcmp(str1,str2)函数有返回值

                                  >0   str1 大
                                  <0   str2 大
                                ==0     相等


  strlen   字符串的长度计算函数

   
  strlen  字符串的长度计算函数

   //  strlen  不含\0
作者: 企业部-阿狗老师    时间: 2015-7-19 00:21


字符串数组还是延续了 一维数组跟二维数组的定义。


相对来说还是算好理解的。


接下来就是开始学指针了。。

这个得好好花时间来研究研究了。  加油。！
作者: 叫什么    时间: 2015-7-19 00:48
写的很详细啊
作者: 企业部-阿狗老师    时间: 2015-7-20 00:13
叫什么 发表于 2015-7-19 00:48
写的很详细啊

这都是最基本的， 从零开始，保持好一个姿态，相信日积月累的力量。这样才能持久！
作者: 企业部-阿狗老师    时间: 2015-7-20 00:15
1、指针变量

              用来存放地址的变量，就是指针变量

2、指针
                就是地址

3、指针变量的定义
            
           数据类型 *指针变量名

  int *p;  // 定义了一个指针变量，变量名是p
          //int表示，p只能存放一个int类型的变量的地址

  char *p1;  //定义了一个指针变量，变量名是p1
             //p1只能存放一个char类型变量的地址

4、指针变量定义的注意事项
  1）"*" 必须得有，如果没有就相当于定义了一个普通变量
  2）指针变量不能用来存放数值或者字符之类的。
  3）指针变量，归根结底还是变量，也有全局和局部变量之分。


指针变量也是变量

   指针变量的使用：  定义指针变量---->初始化指针变量----->使用（使用指针变量简介的修改内存）


      定义的同时进行初始化
1）完全初始化   

        int *p = &a;     //用a的地址初始化，p这个指针变量
                         // 另外一只描述方法：p指向了a

2）部分初始化
      
       int *P = &a,int *p1;   


注意：  如果定义了一个指针变量，但是我们不知道让这个指针指向谁
       int *p = NULL;   // NULL 是空（0）

       int *p = 0       //空

       把一个指针赋值一个空， 什么都不指

     先定义后初始化
        
            int *p;
       p = NULL;


  如果一个指针变量定义以后，如果不进行初始化，这个指针变量存放的是一个垃圾数，这个指针变量，称之为  野指针


    二、用*来获取指针变量指向的储存单元的内容

1、*指针变量    作用：是获取指针变量指向的内存空间的内容
                       获取指针变量值所对应的储存单元
"*"的两种用法
   1）用来定义一个指针变量
   2）获取值








   
作者: 叫什么    时间: 2015-7-20 14:50
恩  谢谢了
作者: HunterTim    时间: 2015-7-20 21:54
昆哥，我来给你加油了，你猜猜我是谁
作者: 企业部-阿狗老师    时间: 2015-7-20 23:34
HunterTim 发表于 2015-7-20 21:54
昆哥，我来给你加油了，你猜猜我是谁

一看就是大牛！。

  坐等去北京带我飞！
作者: 企业部-阿狗老师    时间: 2015-7-20 23:35
约了老师7月24日基础班的电话考核！

   就从今天开始从新回顾一下前三天的内容吧， 看了之后对自己原先认识的IOS开发，C语言有了更深的一层理解。

———————————————————————————————————————————————

1、C语言学习中的重难点
1）运算符：自增、自减运算符
2）进制：各种进驻的转换、原码、反码、补码
3）数组：一维数组、二维数组、多维数组
4）循环：多循环的嵌套、排序、查找
5）函数：递归函数、递归调用
6）指针：一级指针、多级指针、指针和数组、函数、结构体之间的关系
7）内存管理：C语言的内存管理问题、内存泄露、野指针
8）有参宏及条件编译
9）多文件开发：多文件编译、多文件开发


1、C语言的源程序的后缀：.c格式
   C语言源程序：
        1）由函数构成
        2）在一个程序中，只有一个主函数（主函数由系统调用）
        3）函数只有被调用的时候，才执行
        4）如果没有主函数程序无法运行
        5）C语言语句结束一定要有分号


2、C语言源程序分析
     

  int main(){                     int 主函数返回值
    printf("hello world\n");      main  函数名
    return 0;                     （）参数
   }                              {}函数块  
                                   printf 是一个函数，是系统提供的一个函数。
                                     作用是：向控制台输出字符串
                                   return 0;表示main函数返回给系统 一个0
                                  表示程序正常执行，并且已经退出

3、C语言程序执行流程

       写源文件
                    编译
                     ----> .o后缀的目标文件
                                             链接
                                             ------>.out 后缀的可执行文件
                                
作者: 企业部-阿狗老师    时间: 2015-7-22 09:20
1、C语言中的关键字有32个
  其中分两类：1、 数据类型    20个
              2、 控制流程    12个

2、标识符命名原则
   C语言中，符号常量、变量、数组、函数等都需要一等的名称，我们把这种名称叫标识符
   标识符划分：关键字、预定义标识符和用户标识符


  命名规则：
   1、只能由字母、数字、下划线或者美元符号($)组成
   2、不能以数字开头
   3、不能与关键字重名
   4、严格区分大小写


3、整形常量书写
  
   1）10进制整形常量
     10;
   2）8进制整形常量
     以0开头
   045;
    3) 2进制整形常量
     以ob（0B） 开头
    4）16进制整形常量
     以0x 开头
     0x438fa;


  实型（小数）常量的表示方法
      1)单精度常量
       以f结尾         占用4个字节
    2.3f;
      2)双精度常量
     2.3;     计算机中默认的以双精度形式表示一个小数

   字符型常量的表示
       'a';   单引号括起来的字符，就表示字符常量

          特殊的字符常量（转义字符）
       '\n';  '\t'; '\\';   '\r';  "%%"  "\""  "\'"
                      \              %    "      '
    字符串型常量的表示
       "abc";   双引号括起来的字符、数字、符号， 就表示字符串常量

  变量按照作用域分类；
   作用域：可以理解为变量可以使用的范围

  1）局部变量：
   函数的内部或者是代码块的内部定义的变量，都称之为局部变量

  //在代码块的内部可以定义和代码块外部同名的变量，块内部的会暂时屏蔽块外面的作用域。

从局部变量定义的位置开始，到它所在的代码块或者函数体的"}"为止。


2）全局变量：
     在函数的外部定义的变量是全局变量

   作用域：从定义的位置开始，到文件末尾结束，在不同的函数中都可以使用


  printf 的使用格式：
   printf("格式控制字符串",输出列表);

   格式控制符

   %d  输出一个10进制的整数   
   %f  输出一个实数类型的数据（不能输出整形的数据）
          默认的输出6位小数，如果数据小数部分不足6位，要补零
               float   精度有效数字是7位
               double  精度有效数字是15位
     m.nf  格式   m表示总的位数（列数）
                  n表示小数点后的位数
    %c  输出一个字符

    %s 输出一个字符串
  
    %o 输出一个8进制的形式输出

    %x 输出一个16进制的形式输出

    %p 输出地址

作者: 走火入魔    时间: 2015-7-22 22:16
赞一个，我是黑马基础班的，祝福楼主。
作者: 企业部-阿狗老师    时间: 2015-7-24 00:07
走火入魔 发表于 2015-7-22 22:16
赞一个，我是黑马基础班的，祝福楼主。

今天我基础班也考核成功了。

哈哈。

大家一起努力奋斗吧！
作者: 企业部-阿狗老师    时间: 2015-7-24 00:08
二级指针：
   如果一个指针变量存放的又是另一个指针变量的地址，则称这个变量地址为指向指针的指针变量。
也称为“二级指针”

多级指针
    一般有几个*  就好几级指针。

关于指针区分类型。

   结论：定义什么类型的指针就应该指向什么类型的变量。

  数组指针：
   指向数组元素的指针

  数组指针的作用：
    使用数组指针间接访问数组的元素

  数组指针的定义：
   int *p;

  数组指针的初始化：
   int a[4]={1,2,3,4};

  int *p = a;//数组指针，定义了一个指针变量p赋值数组的首地址（第一个元素的地址），p指向数组的第一个元素

  int *p = &a[0];   //等价上面一句话


   数组指针如何访问数组的元素：

   1）p+1      表示指向数组的下一个元素

   2）p-1      表示指向数组的上一个元素


补充：
     引用一个数组元素，可用下面两种方法：

  1）下标法，如  a[i];
  2）指针法，  如*a[i] 或者 *(p+1);
  3)a是常量（a++）是错误，  p是变量 （p++）正确。


   对于一个一维数组来说
    int a[5];
  1）获取a[i]的地址有几种方法

     &a[i];

     a+i;

     int *p = a;        p+i;

2）  获取a[i]的值有几种方法

    a[i];

    *(a+i);

    *(p+i);

    *(&a[i])
作者: 走火入魔    时间: 2015-7-24 22:07
昆哥的狗 发表于 2015-7-24 00:07
今天我基础班也考核成功了。

哈哈。

楼主要学ios吗，是ios基础班啊，我以为是就业班呢，嗯嗯，楼主是哪一期的啊？
作者: 美好未来    时间: 2015-7-24 22:10
赞一个！
作者: 企业部-阿狗老师    时间: 2015-7-25 00:03
走火入魔 发表于 2015-7-24 22:07
楼主要学ios吗，是ios基础班啊，我以为是就业班呢，嗯嗯，楼主是哪一期的啊？ ...

还在 自学阶段呢。 每天都保持着看看。 哈哈。  准备报个基础班。
  本人 非专业出生。
   今天基础班的通知书到了！
作者: 企业部-阿狗老师    时间: 2015-7-25 00:04
美好未来 发表于 2015-7-24 22:10
赞一个！

     一起加油吧 哥们！
作者: 企业部-阿狗老师    时间: 2015-7-25 00:06

  怎么说呢。

    明天就要辞职回家了！

       加上今天被黑马基础班录取了。  是8月26号的班。
   
                今天跟工地的同事们一起大吃大喝了一场。   视频也看到了指针数组了。注意哦是指针数组。

                                  所以今天的笔记就不上传了。！   

                                            反正今天还是蛮开心的。    成功就是进步一点点！
   
作者: 走火入魔    时间: 2015-7-25 21:35
昆哥的狗 发表于 2015-7-25 00:06
怎么说呢。

    明天就要辞职回家了！

支持楼主，加油
作者: 李国峰    时间: 2015-8-19 18:12
不得不服   大神很是用工啊   学习了  你这个学习的态度就是我们学习的榜样




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2