C小结和OC开端

总结:

 

   一、数据定义

   数据类型

      1.基本数据类型

        整型    有符号    短short  int 整int     长整型long int

                    无符号    短short  int 整int     长整型long int

        浮点类型      单精度浮点类型  float  

                              双精度浮点类型  double

                              长双精度浮点类型 long double  C99

       字符型    有符号      字符集 —>ASCII码—>数字0~9

                       无符号      字母a~z A~Z  常见的转意字符

       C99标准中

       布尔类型  <stdbool.h> 且C99标准中才可以使用

       bool 类型   有固定的取值范围  true  !0     false  0

       字符串  类型    <string.h>

                     strcpy() strncpy() strcat() strcmp() strlen()

                     strtok() strstr() strchr()等  atoi()  atof()等 

    2.构造数据类型

       数组    数组能够保存相同数据类型的 有序的 集合。

                   数组其实就是线性表的顺序存储。

                   数组其实就是一段连续的内存空间。

                   数组其实就是批量处理数据的一种类型。是由多个

                           相同类型的变量组成的。

                   1>数组的声明

                       #define N 10

                      类型标示符 数组名[数组元素的个数];

                      类型标示符

                      1.所有的基本数据类型都可以

                        int a[],char a[],double a[],float a[],long    a[],bool a[]

                      2.所有的基本数据类型的指针类型

                        int *a[],char *a[],double *a[]等

                      3.构造数据类型中的 结构体类型

                        struct Student a[];

                      4.构造数据类型中的指针类型

                        struct Student* a[];

                   2.数组名

                      必须是一个合法的类型标示符。

                      合法的标示符

                      1>只能是字母后下划线开头。_a,  a1;

                      2>中间可以出现下划线或数字  a_1, size_t size;

                      3>大小写区分  STUDENT ,student

                      数组名是不能重复，也不能使用系统中已经存在的

                      标示符。

                   3.[] 下标运算符

                      用下表运算符 我们可以对数组中的数组元素进行

                      赋值和取值。

                2>数组的初始化

                     1.通用初始化的方式

                        1>数值数据的

                           int a[10] = {0};

                           char string[20] = {0};

                        2>非数值数据 (地址)

                           int *a[10] = {NULL};

                           char *sring[20] = {NULL};

                     2.赋初始值

                           int a[10] = {0,1,2,3,4,5,6,7,8,9};

                           int b[10] = {0,1,2,3,4,5};

                           char a[5] = {'a','b','3','k','m'};

                        C99

                           int c[10] = {0,1,2,3,c[4]=5};

                3>数组元素的赋值和取值

                      1.下标法  

                         注意：通过数组名[下标]来访问数组的。

                        数组中下标是因为编译器在寻址时方便找到数组

                        中的每一个数组元素，所以设计成下标是从0开始

                        的。

                        a[0];

                        注意：在使用下标时不能够越界访问,即便是老程

                                    序员也经常会出现这种错误。

 

                      2.指针来访问

                         int a[10] = {0,1,2,3,4,5,6,7,8,9};

                         int *p = a;

                        *p   <==> a [0];

                        总结：

                        *(p+i)  <==> a[i];

                  4>数组的分类

                       通过数组的维度   维度指得是数组中下标运算符的

                       个数。一个就叫做一维数组，大于或等于两个的

                       就成为多维数组。

                       1.一维数组

                       2.多维数组：我们是以二维数组为例子。

                   5>数组的基本操作

                        1.数组的遍历

                           for();     for()

                                              for()

                       2.数组的 增  删  改  查  排序  逆序   最值  最多等

     结构体、联合(不掌握)

           ************************|***************************

                       结构体                                数组

    类型:       相同/不相同                    必须相同

    内存:       连续的内存(优化)           连续内存空

                    对齐和补齐                   

 

           1.结构体类型的声明

             知道结构体是一个复合的数据类型，不是单一的一个类

             型，是由多个不同数据类型的 基本数据类型或其他的数

             据类型组成的一个复合的类型。

             表示的是一个类型。

             声明格式：

             类型标示符   结构体名

             {

//大括号里表示的成员变量

                   //可以是一个也可是多个，按需求来定。

             };//;表示声明完毕 不能丢

             类型标示符是 32个关键字之一，表示特殊类型

             struct   Student

             {

 

             };

         2.结构体类型  声明变量

            结构体变量：其实是结构体类型的变量。

            1>方式一

                struct   Student

               {

 

               }stu;

            2>方式二

               struct Student stu;

        3.结构体类型的变量的初始化

           一般我们在声明结构体类型的变量时，通常第二步 和 第三步是写在一起。

           1>方式一

                struct   Student

               {

 

               }stu = {成员变量的类型};

           2>方式二

               struct Student stu = {成员变量的类型};

      4.结构体的嵌套

          1>第一种

             struct Age

             {

                  struct Birthday

                  {

 

                   }birth;

             };

         2>第二种

              结构体类型的变量做另外一个结构体的成员。

             struct Birthday

             {

 

             };

 

            struct Age

            {

struct Birthday birth;

            };

      5.结构体变量中的 成员变量如何赋值和取值

         1.通过  " . "语法  运算符

           格式

           结构体变量名.成员变量名；

           注意：赋值时 如果是基本数据类型 &符号,如果是 字符串

                       类型 不能出现 &；

         2.通过结构体类型的指针

            struct Student *p = &liang;

            p->name;p->no;p->sex;p->score;

       6.结构体类型的指针

           struct Student *point;

           指向的时一个结构体类型的变量。并且可以通过 "->"访问结构体变量中得成员变量。

       7.结构体类型的数组

          数组的类型是一个复合的数据类型，存储的每一个数组元素都是一个结构体类型的变量。

          例如:struct Student stu[];

          复合数组的所有特性，初始化等。

      8.结构体和指针的高级应用

          struct   Node

          {

//数据域

               //指针域

          };

         链表  ——>线性表 

         栈

         队列

         二叉树——>树         

 

枚举    也是一个特殊的数据类型，在C语言中没有真正意义上得

            枚举类型。当做是一个整型去处理。表示是有固定取值

            范围的类型。

            例子：一副牌   4个花色  ，A~K，一周 7天   等。

            关键字  enum 来表示枚举这个数据类型

 

            1.C89 中制作一个bool类型等

扩展：关于 结构体 、枚举、基本数据类型中往往使用typedef来修饰。

    3.指针类型

          指针是一个类型，能保存地址这个特殊的数据类型。

       1>指针和常量的关系 

          指针常量   int *const p;

          常量指针   int const *p 或const  int *p;

       2>指针和变量的关系

          指针类型的变量   也叫指针变量

          类型标示符  *变量名;

          1.指针变量的声明

          2.指针变量的初始化

              int *p = NULL;

              int *q = &a;

           指针指向的变量

              int *q = &a;//关系存在  q->a

           野指针

              没有管的一块内存地址，或存在不可读，或存在不可写或不存在。

              1.第一种 Liunx/Unix/GCC编译器

                没有给指针变量进行初始化

                clang编译器 int *p;Mac下如果不初始化自动置成空。

              2.指针指向的是一个函数内部的变量

              3.动态内存管理时 malloc() 被free以后再修改有可能会造成野指针。

        3.指针和数组

           指针数组   int *a[];

           数组指针  int (*p)[];

           指针做参数传递数组名  int *

        4.指针和函数

           指针函数

           函数指针

           指针做参数在函数中传递(地址)

           1.在函数中想访问域外变量

           2.在函数中想返回多个值。

           例:int fun(int *a,int n);

                int foo(int **a,int m,int n);

        5.指针和指针

           1.一级指针  int *p;int * p; int* p;

           2.多级指针 int **p,int ***p;

 

        6.指针和字符串

           1.字符指针 char *

           2.字符串数组   char *a[];

                                     char *a[10][9];

          3.做参数 做返回值   char *fun(char *s,const char *s1);

       7.指针和结构体

     *8.指针和文件   FILE * (加密程序)

 

4.空类型

       void  参数 和返回值类型空

       void * 通用类型的指针，无类型的指针

5.自定义类型

       typedef  关键字  给已经存在的类型起别名。

       变量  结构体、枚举、函数指针起别名。

 

 

 二、数据操作

 

2.1 运算符和表达式

     1.算术运算符和算术表达式 +-(正 负) * /(取整) % ++ —

     2.赋值运算符和赋值表达式  = += -= *= /= ^=等

     3.关系运算符和关系表达式  == != > >= < <=

     4.逻辑运算符和逻辑表达式 && || !

     5.位运算符和位操作表达式  & | ~ ^ << >>

     6.逗号运算符和逗号表达式 ,

     7.条件运算符和条件表达式    条件?真:假

     8.其他的运算符

        (),[],<>, "." ,"->"等

     9.运算符的优先级   和  类型转换

2.2 程序结构

      顺序结构   选择结构  循环结构

2.3 五大语句

       1.流程控制语句

              条件判断语句  if(),if..else

              多路分支语句 switch…case…break…default

              跳转语句  break,continue ,goto 

              返回语句  return

              循环语句  while(1)  当语句;  效率最高

                                for(;;); 有界性  数组变量  第三母i++ i+=2 表

                                             达式

                                do{}while(1); 菜单专业户 

        2.赋值语句

               a = 100;

        3.复合语句

               if(a==0 && b>1)

        4.函数调用语句

               fun(a);

        5.空语句

               while((*dest++ = *scr++) != '\0')

               {

                   //空语句

               }

2.4 语句+ 变量+ 表达式 === ？

       函数

              1.分类   3类

              2.函数声明  

                 函数一般格式:   

                  返回值类型 函数名(形参列表);

                 返回值类型：

                 1.基本数据类型

                    int add(int x,int y);

                    double add(double x,double y);

                 2.指针类型 

                    char *strcat(char *s,const char *s1);   

                 3.结构体类型的指针

                    struct Student *makeNode(int a);

                 1>显式声明

                 2>隐式声明

             3.返回值   参数    名称

             4.函数的调用

                 1.函数一般调用   fun(a);  函数名(实参);

                   有返回值时要特别注意。

                 2.函数嵌套调用

                     1>一般嵌套

                          f1()

                          {

 

                          }

                          f2()

                          {

    f1();

                          }

                    2>函数的递归调用

                        树 的遍历    二叉树   先  中  后

                        当调用的另外一个函数恰好是它本身时，调用就

                        是递归调用。

                         1.直接递归      2.间接的递归

                        注意事项：3条    

            5.函数传参

                  1.值传递     传递副本    形参改变不影响实参。

                     例如：基本数据类型  数组中某一个数组元素。

                  2.地址传递    传递是本身  共享一块内存  形参改变直

                                         接影响实参。

                     例如：配合指针使用  指针做参数 或 传 a[]。

                     深刻的去理解指针？

                              1>第一种 就是你想访问域外一个变量用地址传

                                              递。

                              2>第二种 就是想让还是返回多个值。

           6.变量和变量的作用域

              1.全局变量   作用域

              2.局部变量   作用域

         *7.关于变量作用域的限定符

              1.static 静态变量

              2.auto 自动类型变量

              3.extern 全局

 

3.内存管理    预处理

 

    3.1 预处理的指令

          1.宏

          2.文件包含

          3.条件编译

    3.2动态内存管理  <stdlib.h>

         malloc();free();函数即可

         堆、栈   知道C语言程序 运行时 占内存的情况。

******************************************************************

 

Day01 Objective-C语言程序设计

 

1.Objective-C 是C语言的一个超集，Objective-C完全兼容于C。是扩展C的面向对象的编程语言。C语言是面向过程的高级的 一种弱类型的高级语言。

 

2.Objective-C简称 OC或Objc

   Objective-C是一种简单的计算机语言，是面向对象的一种变成语言。

   OC通过提供 类的定义、方法以及属性等语法，还有其他的可以调高类的动态扩展能力的结构等(分类   协议) 扩展了标准C 语言。在OC中类的语法主要是借鉴了 SmallTalk变成语言，是最早的面向对象的语言之一。

   OC是C语言的一个超集。所谓超级说得是 OC支持所有C语言的基本语法。

 

3.知识的衔接

    *****************|****************|*******************

              C                       C++                   OC

 

    *.h  头文件          *.h头文件                *.h表示头文件

    *.c 小写c             *.C或*.cpp或*.cc   *.m 或*.mm

 

   @指令符

       凡是带有@ 指令符的内容就表示告诉给编译器 这个语法是OC语言中特有的。

   例如：@interface 

 

   #import<> 或#import "" OC中不再使用#include <>或

   #include ""，因为#include <>或""不能自定剔除重复的头文

                          件。

 

  [消息语法];

  

  NS前缀   NextStep公司 计算公司，Objective-C 1986年，Objective-C2.0标准 NS。

 

4.面向对象的编程思想

   面向对象是一种思想，源于人们对自然界的最基础、最直观的认识。

   面向对象的编程思想是把 我们的程序看做是由不同功能的模块组合起来的。

   面向过程  =  数据结构 + 算法；

   面向对象 = 对象1 + 对象2+对象3.

   对象 = 属性 +行为；

   1.什么是面向对象的思想？

     面向对象是一种思想，最早出现在人类的生活中，人类对自然界最直接的认识。（万事万物皆对象），后来才被引入到计算机的工业进程中来，我们可以把大型的程序看做是由很多个不同属性和行为的对象的集合。

   使用这种思想好处，可以实现模块化编程，能够降低开发成本和开发的时间周期。这样提高了工作效率，使得模块化编程更易于维护和修改。

   2.为什么要使用面向对象的思想？

       A.因为面向对象的编程思想被广泛的运用了到GUI图形交互界面的开发中，如 IOS UIKIT   C++ MFC  QT(C++)等都是面向对象的语言来实现的，所以说到目前为止没有一种更好的语言能够代替面向对象的语言。

       B.向一些不支持面向对象语言  C语言中，也仿照了面向对象的特点，加入了部分支持图形化编程的程序。

          如:GTK开发环境 被广泛的应用到嵌入式编程。 带图形交互界面的开发。  

          例如：linux系统中  bash下 gdialog图形编程。

       C.是因为我们使用网络编程三方库 都是把底层的C语言的SCOKET套接字技术 封装的一个三方库。

          C++中  ACE   Boost库   谷歌AsyncSocket等

       D.目前市场上流行的数据库  Oracle 10g,11g 以及Oracle云存储。MySQL 4.6等  SQLite3等 移动开发平台上使用的数据库。都是使用面向对象思想封装的数据库。

       E.为了降低成本，以及缩短开发周期。大大的提高了开发的效率，增加代码的复用性。降低了开发的难度。

 

   3.怎么样使用面向对象的思想？

      至少要掌握一门  UML  统一建模语言。

      流程图、类图、用例图。

 

5.面向对象的特征

   1.抽象性 ——现实生活中得某一个事物，抽象出一个数据类型来描述这个事物的属性。

  2.继承性 ——客观存在的事物都由共性、也有特性。如果只考虑共性，而不考虑特性，我们不能很好的反映出事物在现实世界的客观存在。也就不能反映 类的层次关系。也就不能正确的用抽象性准确的描述事物。

      运用抽象性的特点 就是要 发现事物的共性，提取出来，先舍弃它的特性。从而得到一个适合所有对象的类。这个类我们就称为是父类(基类)。然后在考虑每一个事物的特性，从而在基类的基础上派生形成一个新的类。这类就叫做派生类(子类)。这样形成的类之间的层次结构 我们就称为是 继承结构。

      继承 是描述两个类 之间的 层次关系。

      子类不但拥有父类(基类) 中所有的属性和行为还拥有自己的

      新的属性和行为。

  3.封装性 —— 就是把对象的属性和行为封装(组合)起来形成一个独立的单位，并且尽可能的隐藏对象的内部细节。

     尽量的让一些成员变量或属性 不被暴露出来。

  4.多态性 ——就是指类中的统一函数名称的函数，对应多个具有相似功能的不同函数。

     借鉴于现实生活中得例子。

     例子：吃饺子

 

 

6.面向对象的工具

   类

         1.什么是类？

           具有相同 属性和行为的同一类元素的总称，就叫做类。

           类是一个复合的数据类型，用于存储 成员变量 和 函数

           (方法)

           类是一个数据类型   根据现实世界中的客观存在 抽象出

           来的一个数据类型。是一个抽象的概念，没有具体的意   

           义。

           例如：人类  动物    蔬菜类   水果类  汽车类。

 

   对象

         2.什么是对象？

            对象就是类这个类型的一个具体实现(实例)。

            表示的是具体的某一个实例。

            比如：人——类

                        张三——对象

           对象就是类在内存中的一个实例。

          区别类和对象的方法，是看哪一个是否还能继续再分。类是一个抽象的概念(可再分)，对象是一个具体的概念，不能再分了。

          对象是由   属性  和  行为来构成的。

          对象的属性： 用来描述对象的特征。

          对象的行为：描述的是对象的功能(行为)。

          例如：狗(类)——>小Q的金毛(对象)

                                           品种：金毛

                                           眼睛：黑色   <——狗(小Q)的属性

                                           毛色：金色

                     狗跑——>嗖 。。嗖。。。

                     狗叫——>汪。。汪。。。<——狗(小Q)的行为

                     狗睡——>呼。。呼。。。

   成员

 

            1.是类中出现的 成员的概念最早在结构体中被提出来，我们这里只的成员是类中的成员变量和成员函数。

 

 

一、类的语法结构

 

1.类的声明部分

  @interface 类名:父类名

   {

       //成员变量

   }  

   //方法的声明 (方法实质是函数  叫方法)

  @end

   注意：成员变量的命名规范

   类型标示符  _成员变量名;

   ：表示的是继承关系 记住是OC中所有自定义的类都是派生

       类。都可以说是NSObject这个类的派生类,NSObject是OC

       中所有类的根类。(根类和基类不一样)

 

2.类的实现部分

   实现部分 实现是谁？

   答：实现部分 指的是实现的 类声明中 声明的方法。

           方法的实质（函数）。

           对象是实质（变量）。

           类的实质（类型）。

   语法：

   @implementation 类名

 

   @end

 

   例如：车 Car——>类(BMW QQQQ )

 

 

3.成员变量

   写在类声明的部分中大括号里的内容

   @interface 类名:父类名

   {

       //成员变量

   }  

   //方法的声明 (方法实质是函数  叫方法)

  @end

  注意 命名规范。

 

4.函数声明(也叫方法)

   

   C语言中函数

    返回类型  函数名(参数);

    int add(int x,int y);

 

   4.1 OC中函数的语法格式

    

   类型标识  (返回值类型)函数名:(参数的类型)参数名;

   +/-

   + 表示你声明的函数的类型是一个  静态函数，也叫类方法。

   - 表示你声明的函数的类型是一个  动态函数，也叫对象方  

      法(实例方法)。

   类型标识  (返回值类型)函数名:(参数的类型)参数名 andWith:(参数的类型2)参数名2;

 

  4.2 OC中函数的调用(方法的调用)

         1.如果是 - 方法 也叫对象方法，也叫实例方法

           -(对象)方法用对象调用。

           +(类)方法用类名来调用。

 

         2.函数调用的语法  [ 消息语法 ];

 

            -方法  对象方法的调用

            [对象名   方法名];

 

 

作业：

1.敲代码

  熟悉  类的声明和实现

  掌握  成员变量的声明

            函数的声明

            不带参   带一个参数    带多个参数的声明和实现

  Demo2 背下来创建对象的方法

 

  类名 *对象名 =[[类名  alloc]init];

 

  掌握 -方法  对象方法的调用 即可；