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
蛮拼的。。。哎

看似 很拼。  其实每天都是花很少的时间来干的，  还有很多的不懂很不理解。

1、有关include的使用
#include  是一个预处理指令


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

#include  表指令  ， 包含文件

#include"  "包含自定义文件

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


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



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


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



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

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

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

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

好处：  用的时候，只需要把.h文件，对外隐藏源文件的实现
        团队的分工跟协作
        可以吧工程细化分若干个模块

今天学习的是进制问题。


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


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）在原码基础上符号位不变，其他位取反。

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）变量的地址：变量的首地址（变量在内存中占用的存储单元中地址）

  整型变量修饰符
    改变整型变量占用的存储空间
     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码值等他的字符

今天开始学习的是C中一个听大家说比较重要的内容——数组！

所以看的比较仔细。

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

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

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

学习之路，任重而道远。 努力前行，不离不弃！

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
数组的引用（访问）：数组名（下标）就可以访问数组的元素

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

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个字节

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  位置数

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(数组类型）


   

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";




  

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:48
写的很详细啊

这都是最基本的， 从零开始，保持好一个姿态，相信日积月累的力量。这样才能持久！

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）获取值








   

恩  谢谢了

昆哥，我来给你加油了，你猜猜我是谁