精华内容
下载资源
问答
  • IOS 静态方法与动态方法详解 1、问题提出  iOS中有静态方法与动态方法,那么两种方法的异同是什么? 2、问题分析  因为每个对象都由相应的数据结构与方法相构成,一个程序可能有多个属于同一个类的对象,而每个...
  • Java面向对象基础篇

    2021-02-03 22:24:37
    面向对象:(类+对象)==表格 所有的数据,都可以看成是表格,只有静态动态 类(c结构体)== 表的结构class 动作类&静态类 包含一堆可以不同类型的变量。 定义(空的类) public class Car { } class type{ } ...

    一、面向对象OO:(类+对象)==表格

    1. 所有的数据,都可以看成是表格,只有静态和动态
    2. 以类的方式组织代码,以对象的方式组织(封装)数据。

    1. 面向过程:执行者思维(简单问题)

    • 可视?
    • 步骤1,2,3…

    2. 面向对象:设计者思维(复杂问题)

    • 先思考解决问题需要分哪些类,再对类进行单独思考,类中间是细节考虑的东西。
    • 面向对象包括(封装了)面向过程。
    • 不可视?
    • 协作问题。

    二、类

    • 即:属性(私有)+方法(public、set、get)== 表的结构class
      静态类、模板、设计者

    • 包含一堆可以不同类型的变量。

    1.定义、创建、初始化使用

    • 不是每一个创建的类都需要一个main()函数,只是单纯的需要一个方法,放置一堆对象,并且进行相关的操作。
    • 一个project一般只有一个main()函数。
    public class Car {
    
    }
    class type{
    
    }
    
    • p1、p2对象就是Person类的具体实例。
    		Person p1 = new Person();
            Person p2 = new Person();  
            System.out.println(p1.name);
    
    • 用new创建的情况下,刚刚创建好的对象,会进行①分配内存空间+②默认进行初始化(null、0、false)+③对类中构造器调用
            p1.name = "小明";
            p1.age = 18 ;       //静态初始化
    
            System.out.println(p1.name+"\t"+p2.name);
            System.out.println(p1.age+"\t"+p2.age);
    

    ♥♥构造器:constructor四个要点:

    • 对对象的属性进行初始化工作。
    1. 关键词new来 调用:本质:调用构造器。(new 调用构造的方法)
    2. 有调用,有return返回值
    3. 构造器的方法、名称必须与类相同(大小写也得相同)
      方法:是公用的。
    4. 隐式构造出:如果没有定义该构造器,idea会自动定义添加一个 无参的 有初始值,没有返回值return,也不能写void 构造方法。(默认一个隐式参数,this)
      this.id指的是上面这个 类的id。
    • 定义有参构造之后,如果要使用无参构造,显示地定义一个无参的构造器。

    三.对象object,instance

    动态的、过程、方法。 是具体实例

    • 一个对象:包含上述类中的每一个变量。这么一片叫一个对象。
    • 可以有多个对象。

    四、面向对象的内存分析 ♥

    目的:理解对象

    java虚拟机内存模型概念:

    1.线程

    • 栈stack:连续的,动态的
      ①程序计数器:记录执行到哪一步,下次执行知道从哪里开始。
      ②java虚拟机栈:栈帧(JVM为每个线程创建一个栈)
      ③本地方法栈:操作系统
      ④main()在栈底

    2.堆

    • heap(存数组):不连续的,新建的new
      划分不同分区,根据需求不同,分得不同的时间空间,(传值), 方便垃圾回收。
      (不动的)

    3.方法区

    • 也属于jdk (堆),不连续的,静态的
    • 是一种java虚拟机的规范。(静态方法区:放一些不变的)
      (模板、不动的)

    运行时常量池:
    直接内存:可以直接去交互的内存块。


    4.JVM回收垃圾

    垃圾回收机制 GC:(garbege collection)

    • 自动回收(new的),回收没用的,赋值null即可。

    垃圾回收算法:

    ①引用计数法:减减,至0时,回收。
    循环引用的无用对象无法识别。
    ②引用可达法(根搜索算法):
    找根,再找有应用到的节点,剩下的就是没有用过的节点,被GC掉。

    5.分代垃圾回收机制:

    ①年轻代 Eden、Survivor(很少用的)

    • Minor GC:Eden(一起用完才清空);
      Survivor1,2(没请掉的到这里来);
      再清,清了15次还没清掉,丢到年老代去。

    ②年老代Tenured/Old(经常用的)

    • Major GC年老代;
      Full GC:全量回收,大扫除,全面清除掉所有我能控制的区域(年轻+年老)

    ③永久代(一直在用的)
    与JVM共存亡。

    • JVM调优,很大部分对于Full GC,
      System.gc():“建议”启动垃圾回收,而不是调用运行。
      但是大部分都会接受建议。

    6.this 、static关键字

    • this:创建好的对象的地址

    a.this的常用用法:

    1. 产生了变量名字重名的歧义,可以用this表示当前对象。
      普通方法中,this指向调用该方法的对象;
      构造方法中,this指向正要初始化的对象。

    2. this关键字调用重载构造方法时,避免相同的初始化了。
      但只能在构造方法中用,并且位于构造方法的第一句

    3. this 不能用于static方法中。


    b.static关键字:

    • 静态初始: 代码块前面加 static
      在静态初始化块中,不能直接访问非static成员

    7.变量的分类

    1.局部变量

    方法或语句块内部声明;属于方法/语句块:从该方法开始,到这块执行完,变量消失。
    

    2.成员变量(实例变量)

    类内部,或者方法的外部声明;属于对象。对象创建,变量创建,随对象的消失变量一起消失。
    

    3. 静态变量

    在类内部声明,用static修饰;属于类。类被加载,静态变量就有效,随编译器的启动而启动,关闭而消失。所有都可以访问。
    

    8.包机制

    • package:相当于文件夹
      开源的,起名有要求:用域名作用的名字。(域名倒着写)com.yuming.test…
    • com.yuming和com.yuming.com区别:逻辑上有父子关系但是实际上是两个完全独立的个体。

    JDK中的主要包

    核心包

    1.java.lang:**String**、Math、Interger、System、Thread提供常用功能
    (这个核心包可以不用导入就使用)
    2.java.awt:集成窗口工具集的多个类,构造管理应用程序图形用户界面(GUI)(少用的)
    3.java.net:执行类与网络相关的操作类
    4.java.io:提供多功能输入/输出类
    5.java.util:包含一些实用的工具类,如定义系统特性、使用与日期日历相关的类
    

    import导入新的包♥

    • import . com. yuming .包名.*;
      不存在先后顺序。

    • 具体到导入某一个类:全部写进去;

    • 外面的其他包我都想要:不用具体到class,用 .* 表示;(会降低编译速度,不会降低运行速度)
      ···

    • Alt+Enter可以快捷键自动导入。


    五、继承 extend

    • 私有属性(变量),共有方法(类),get、set方法获取。
    • get、set驼峰命名规则:alt+shift+insert自动生成
      意义:
    1. 提高程序的安全性,保护数据
    2. 隐藏细节
    3. 统一接口
    4. 提高系统的可维护性。(修改内部代码)

    1.单继承

    类与类的关系:

    • 类只有单继承:只有一个直接的父类
    • 接口有多继承

    - 继承的实现:代码的复用

    可以继承属性和方法。(扩展extends)
    	class xxx extends yyy{
    	}
    
    • 公共的public才可以继承,私有的不可以继承。

    • public、protected、default、private优先级依次往后。

    • 虽然可以继承所有属性和方法(父类构造法除外),但不一定所有的都可以直接访问(如私有属性)


    2.组合

    收购了,并购了。

    this.person.name = dog;
    

    3.继承和组合

    都可以实现代码的复用。

    • 继承:is - a的关系
    • 组合:has-a的关系

    (逻辑上的关系注意一下)


    六、override 重写

    • 覆盖

    • 子类重新定义父类。(父类的引用指向了子类)√

      父类B 变量b 指向= 引用new子类 A();

      (方法的调用只和左边的有关)

    1.重写的特点:

    1. 是父类和子类才有的(存在继承关系)。是子类重写父类的方法。
    2. 方法名必须相同。
    3. 参数列表必须相同。(否则是重载了)
      重载是名字或者参数列表有不一样。
    4. 修饰符:范围可以扩大,不能缩小:public最大,protected,default、private最小。
      (子类可以访问的范围更大,优于父类)
    5. 抛出异常:异常的范围可以被缩小, 但不能扩大。(继承之后一定变好了,不能越来越差了)

    重写子类和父类的方法必须一致,方法体不同。

    	即符合:
    	  ①“= =”:方法名、形参列表相同
    	  ②”≥“:访问权限,子类大于等于父类
    	  ③“≤”:返回值类型和声明异常类型,子类小于等于父类。
    

    2.重写的原因:

    • 父类的功能:子类不是所有的都需要,也不是都满足需要。

      ALT+shift+INSERT : override


    3.final关键字

    1. 修饰变量:被它修饰的变量不可改变。不可以重新被赋值
    			final	int MAX_SPEED = 120
    1. 修饰方法:方法不能被重写,我的方法不可以被子类重新修改,但是可以被重载。(可以随便用,不可以改)
    		final void study(){
    		}
    
    1. 修饰类:修饰的类不可以被继承(不需要子类了)。如Math、String。
    		final class A{
    		}
    

    4.object类:

    • 是所有java的父类(根)
    • 也就是:所有的除了构造类的都能被继承,但是不一定都能用。(如私有的就不能使用)
    	public class Person{
    		...
    	}//等价于以下:
    	
    	public class Person extends Object{
    		...
    	}
    
    • object类包括:
      hashCode();toString(); clone();getClass();notify(); wait(); equals();等…

    1.toString方法

    • 可以自动调用返回值为String类型的方法;

    • s.toString(); 直接输出时,括号里面可以不写。

    • 可以重写toString。

    • toString()方法默认返回的字符串是: 对象+@+地址。

    2.==号与equals方法

    	public boolean equals(Object obj){
    		return (this == obj);
    	}
    

    是否与当前的hashcode一样。(两个对象是否相同)


    3.super

    • 可以看作时直接父类对象的引用。可以用来访问父类中被子类覆盖的方法和属性。

    - super的注意点:

    1. 所有的构造方法第一句总是super(…)或者this(…)。因此,自己不调用时,系统会自动调用无参的super();构造器。
    2. super调用父类的构造方法,必须在子类构造器的第一行
    3. super 必须只能出现在子类的方法或者构造方法中
    4. super和this不能同时调用构造方法!(因为super 和this 调用都得在第一行)

    - super 和 this区别:

    1. 代表的对象不同
      this:本身调用者这个对象
      super:代表直接父类对象的应用
      前提:

    2. this:没有继承也可以使用(可以直接使用,默认的)
      super:只能在继承条件下可以使用

    3. 构造方法:
      this(); 当前本类的构造
      super();直接父类的构造


    七、封装encapsulated

    • 实现高内聚,低耦合。(封装类的内部细节,便于修改内部代码,而不许外部干涉,提高可维护性;简化外部调用,便于调用者使用,便于扩展和协作。)

    1.访问控制符

    • 从而实现封装

    1.private

    私有,只有同一个类可以访问。

    2.default

    没有修饰符修饰,只有同一个package的类可以访问。(一个包中多个类都可以访问)

    3.protected

    可以被同一个包的类以及其他包中的子类访问。(同类+同一个包的不同类+不同包的子类)

    注意:♥

    1. 父类和子类在同一个包中时,子类可以访问父类的protected成员,也可以访问父类对象的protected成员。
    2. 父类和子类不在同一个包中时,子类可以访问父类的protected成员,但是不能访问 父类对象的protected成员。

    4.public

    所有类都可以使用,只要是这个project就可以使用。

    2.封装的使用细节

    简单规则:

    1. 属性:一般使用private访问权限
    2. 属性私有后,提供相应的get/set方法来访问相关属性,这些方法通常是public修饰。(Boolean 变量的get方法是is开头的)
    3. 方法:一些只用于本类的辅助性方法可以用private修饰。
      有需要其他类调用的方法public修饰。

    八、多态polymorphism

    • 方法的多态:同一个方法的调用,对象的不同行为引起的。= =重写 override(方法体)

    • 一个类的实际对象是确定的,但是可以指向这个对象的 引用类型是任意的:他的本类、父类、祖宗object等等都可以引用同一个类。

    Student s1 = new Student();
    Person s2 = new Student();
    Object s3 = new Student();
    
    • 右边的为实际对象。能执行的方法组要看左边的类型,和右边关系不大。左边有才可以用。

    1.对象的转型

    case转

    • 而父类是不可以调用子类后面的私有方法。

    • 高转低的话,可以强制类型转化。

    - 多态的注意:

    1. 多态是方法的概念,属性没有多态。(override的本质)
    2. 父类与子类之间继承关系时,才可以强制类型转换。
      不相关无联系的类时如果强制转化:异常报错:ClassCastException!
    3. 存在的条件
      ①是继承关系,
      ②方法需要重写。
      ③父类的引用指向子类对象。Father f1 =指向 new son();

    - 不可以被重写的:

    1. static
    2. final
    3. private

    也就不存在多态。


    2.抽象方法和抽象类

    • 抽象方法:就是一种声明
      使用abstract修饰;
      没有方法体
      具体实现是通过子类提供的具体方法实现的。

    • 抽象类:abstract定义的规范。抽象方法没有确定的。包含抽象方法的就是抽象类

    - 抽象类的使用要点

    • 是个规范,但是不一定每个人都可以做到。
    1. 有抽象方法的类只能定义成抽象类;
    2. 抽象类不能实例化,即不能new一个;
    3. 抽象类包含属性、方法、构造方法。但是构造方法不能用来new实例;
    4. 抽象类只能用来被继承;
    5. 抽象方法必须被子类实现

    3.接口(interface)

    只有抽象方法和常量。

    • 接口 : 契约(本质:还是抽象类)…如果是xxx,则你必须实现…
    • 只有规范,只有方法的类型。自己无法写方法:是专业的约束。
    • 是规范(方法声明)与实现的分离。

    - 区别♥

    • 普通类:具体实现
    • 抽象类:具体实现+规范(抽象的方法)
    • 接口:规范

    - 接口的作用:

    1. 接口是约束。
    2. 实现类可以实现多个接口,也就是接口可以实现多继承
    3. 定义一些方法,让不同的人实现,接口一样,实现的方式不一样。
    4. 方法:所有的类型都是public abstract类型的类。
    5. 静态 常量(属性): public static final
    6. 调用:直接void(do);
    7. 接口不能实例化,因为接口中不可以构造方法。
    8. 可以实现多个接口:通过implements
    9. 实现接口中的类之后,必须重写接口中的方法。

    - 接口的使用

    1. 默认public abstract void xxx();抽象方法;
    2. 默认public static final类型的常量;
    3. 接口可以多继承;

    - 接口的默认方法和静态方法

    • 也被称为是扩展方法。
    • default关键字表示默认方法。
    • 所有这个接口的实现的类都会继承这个方法。
    • 从属于接口(一种特殊的类)。
    • 默认方法是静态的。

    - 接口的多继承

    可以有多个父类:可以继承与多个父类。必须实现所有的方法。


    4.instanceof 运算符

    用来判断一个对象是什么类型:判断两个关系是否存在父子继承关系。
    

    A instanceof B:
    能不能编译通过,取决于A与B之间是否存在继承关系。
    三条关系线:
    Object>Person>Student
    Object>Person>Teacher
    Object>String

     		
     	1	Object s1 = new Student();
    
            System.out.println(s1 instanceof Student);  //true
            System.out.println(s1 instanceof Person);  //true
            System.out.println(s1 instanceof Object);  //true
            System.out.println(s1 instanceof Teacher);  //false
            System.out.println(s1 instanceof String);  //false
    

    所以,s1,与teacher、string不在同一棵树上。

    	2	Person s2 = new Student();
    		
            System.out.println(s2 instanceof Student); //true
            System.out.println(s2 instanceof Teacher);  //false
            System.out.println(s2 instanceof Object);   //true
          //  System.out.println(s2 instanceof String); 直接编译报错,直接不同路线。
            System.out.println(s2 instanceof Person);  //true
    

    k

     	3	 Student s3 = new Student();
     	
             System.out.println(s3 instanceof Student);  //true
          //  System.out.println(s3 instanceof Teacher);	直接编译报错,同级不同路线
            System.out.println(s3 instanceof Object);  //true
           // System.out.println(s3 instanceof String);		直接编译报错,直接不同路线。
            System.out.println(s3 instanceof Person);  //true
    

    - 类型之间的转换(非基本类型)

    1. 强制类型转换(会丢失方法)= = = 高(父)- - - > 低(子)
    2. 向上转型:不用强制转换,添加方法等
    3. 方便方法的调用,减少重复代码。

    5.常用类

    1. 包装类
      八大基本类型都有:自动装箱和拆箱。(因为需要面向对象)

    2. 枚举类:
      最基本的用法掌握即可:

    定义:   enum 枚举名字{
    		枚举体(简单的列表常量)最后一个末尾可以不写分号
    	}
    
    遇到复杂的东西时候,直接创建一个其他类即可。
    

    创建枚举类型:

    enum Season{
        SPRING,SUMMER,AUTUMN,WINTER
    }
    
    System.out.println(Season.SUMMER);
    

    遍历输出:

            for(Season k : Season.values()){
                System.out.print(k+"\t");
            }
    

    switch与枚举:

    	 int a = new Random().nextInt(4);//生成0,1,2,3四个随机数。
            switch(Season.values()[a]){
                case SPRING:
                    System.out.println("春天");
                    break;
                case SUMMER:
                    System.out.println("夏天");
                    break;
                case AUTUMN:
                    System.out.println("秋天");
                    break;
                case  WINTER:
                    System.out.println("冬天");
                    break;
            }
    

    九、异常:Exception

    • Process finished with exit code 1
      后面是1,表示存在异常;后面是0表示正常退出。
    • 出现异常的时候,程序可以安全退出, 处理完之后继续执行。
      用户输入的问题、不存在的问题、内存不够的问题…
    1. 被除数为0:ArithmeticException:运算条件异常
    2. 检查型异常:用户错误或问题引起的异常,程序员无法预见的。
    3. 运行时异常:写的时候不报错,运行时可以在编译时忽略。
    4. 错误:非异常。栈溢出等。如无限循环:StackOverflowError

    异常的分类:

    Throwable类、Exception、Error(jvm出错,重启。。)

    Exception:

    • RuntimeException(UncheckedException)运行时异常,编译器不知道,编译的时候不会报错;
    • CheckedException:编译时的异常,编译时候就通过不了

    异常类结构层次图:
    异常类层次结构图

    异常的处理

    1.抛出+捕获异常:

    处理异常的五个关键字:try、catch、finally、throw、throws
    快捷键:自动包裹代码捕获异常:选中当前代码+Ctrl+Alt+T:try/catch/finally

    1. 分成三块:try+catch+finally。可以使用多个catch: 但是假设要捕获多个异常,异常必须从小到大捕获。Throwable、其次Exception,最小error,最先写error。
            try{					
              //想要捕获的异常类型
                System.out.println(a/b);//语句1
                System.out.println(c/d);//语句2
                 
            }catch (Error e){				
            //catch 捕获异常(先小后大)
                System.out.println("Error");
            }catch (Exception e){
                System.out.println("Exception");
            }catch (Throwable e){
                System.out.println("Throwable");
            } 
            finally {           
            //善后工作(不管有无处理异常,都正常输出)
                System.out.println("finally");
            }
            //finally 可以不要,用于:假设IO资源关闭,就会用到。try、catch 一定要。操作系统的资源也得关闭。
    
    注意: 1.catch后面的语句如果是由父子关系的时候,先写子类,后写父类。没有父子关系可以不管先后。
     		2.语句1出现的异常,往后解决之后,不会再返回语句2.
    

    2.声明异常

    • 谁调我谁处理。(推迟处理 )
    1. Throw:手动抛出异常,在方法中使用
        public void test(int a,int b){
            if (b==0){
                throw new ArithmeticException();     //主动抛出异常,方法中使用
            }
    
    1. Throws:假设这方法中,处理报不了这个异常。方法上抛出异常
        public static void main(String[] args) {
            try {					//用了try、catch捕获异常之后,程序继续往下执行,如有异常,直接此处结束
                new Test().test(1,0 );		//匿名内部类
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //假设这方法中,处理报不了这个异常。就在方法上抛出异常
        public void test (int a,int b) throws ArithmeticException{					//方法上抛出异常
            if (b==0){
                throw new ArithmeticException();			
                	//方法中主动抛出异常
            }
        }
    
    1. ♥ throw 和 throws的区别:几乎没有相同的地方。
      throw:生成一个异常对象,并手动抛出,在方法内部;
      throws:自动、在方法声明的末尾处,抛出异常(处理异常的方式)。先存在异常,“上有排污,下游治污”

    3.try-with-resource自动关闭

    本质上还是try-catch-finally。
    自动关闭资源。
    try(****);{ }
    自动实现了AutoClosable的接口。
    可不用finally。jvm跑的还是try-catch-finally。

    4.自定义异常:

    1. 进入可能会存在异常的方法

    2. 传递参数a

    3. 判断是否要抛出异常,无则继续输出

    4. 对这个方法的参数进行调用,捕获自定义的MyException异常

    5. 打印异常的消息(自定的MyException异常里的toString();)

    (规划一整套异常体系比较难)

    处理异常的思路

    1. 细心看异常信息,确定异常种类、相关代码行(独立解决50+);
    2. 确定上下文相关的关键词信息(疑难问题,需要);
    3. 拷贝异常信息百度10篇以上,查看相关帖子,找思路(搜具体名词、再减少关键词放宽条件)(用空格代替标点符号);
    4. 前两步不会再向同级请教;
    5. 前三步无法解决,请教领导。

    - 总结:

    常见的RuntimeException异常:自己要解决的

    1. ArithmeticException
      逻辑上的不严密造成的,比如除数为0;这种情况下要加以控制语句if何时可行条件,修改。
    2. NullPointerException
      空指针异常:对象(变量在栈中)是空的时候,调用了他的方法(此时堆中是没有的)。
      解决方法:加以判断if(变量!= null);
    3. ClassCastException
      不可以转换的类型:if(a instanceof b){ }来判断一下是不是同一个类型的,是的话可以强制转换,不是就不转了。
    4. ArrayIndexOutOfBoundsException
      数组越界了:范围之外(数组)
      解决方法:加以判断if(a>0&&a<arr.length){ }
    5. NumberFormatException
      数字格式化异常:引入正则表达式判断是否为数字。

    CheckedException异常

    1. 创建的时候异常:可以检查出来的。
      直接添加抛出异常

    实际应用中的经验总结

    1 . 处理运行异常时,采用逻辑去合理规避同时辅助try-catch处理
    2. 在多重catch块后面,可以加上一个catch(Exception)来处理可能会被遗漏的异常。
    3. 对于不确定的代码,也可以加上try-catch,处理潜在的异常
    4. 尽量去处理异常,切记不要只是简单的调用printStackTrace()去打印输出,在printStackTrace()前面,增加一些处理异常的代码块(把我们的损失降到最低)
    5. 具体如何处理异常,要根据不同的业务需求和异常类型去决定
    6. 尽量添加finally语句块去释放占用的资源:IO流、Scanner等

    展开全文
  • C语言C++学习路线

    2020-06-28 14:53:53
    类的封装,构造和析构、静态成员、对象管理; 类的构造(有参构造函数、无参构造、拷贝构造、默认构造函数)和析构; 对象动态管理、友元函数、友元类、操作符重载; C++编译器对象管理模型分析; 类对象动态管理...

    C语言
    数据类型、变量、内存布局、指针基础;

    字符串、一维数组、二维数组;

    一级指针,二级指针,三级指针,N级指针概念,指针数组和数组指针;

    结构体、文件的使用;

    动态库的封装和设计;

    函数指针回调函数。

    C++初级编程
    面向对象编程思想;

    类的封装,构造和析构、静态成员、对象管理;

    类的构造(有参构造函数、无参构造、拷贝构造、默认构造函数)和析构;

    对象动态管理、友元函数、友元类、操作符重载;

    C++编译器对象管理模型分析;

    类对象的动态管理(new/delete);

    友元函数和友元类;

    运算符重载(一元运算符、二元运算符、运算符重载难点、项目开发中的运算符重载);
    类的继承、多继承及其二义性、虚继承;

    多态(概念、意义、原理剖析、多态案例);

    虚函数、纯虚函数、抽象类(面向抽象类编程思想案例);

    函数模板、类模板,模板的继承;

    C++类型转换;

    C++输入输出流(标准I/O 文件I/O 字符流I/O);

    C++异常处理(异常机制、异常类型、异常变量、异常层次结构、标准异常库);

    常见常用的IDE开发工具
    诸如Windows平台VC系列:VC++6.0(比较古老) ;Visual Studio2013, Visual Studio 2015,Visual Studio2019;Mac平台的XCode系列,还有CodeBlock,另附一些高级编辑器Notepad++,EditPlus,UE等一些开发工具的常用设置和一些常见快捷键的使用。

    此阶段的学习难度系数不大,掌握这些内容之后,可以做些简单的小项目。当然了如果你想用这些技能找工作的话确实是比较困难的。这时你还应该在加把劲进一步学习第二阶段。

    C/C++开发进阶
    这一阶段的目标才是达到C/C++软件工程师开发行业的基本要求,这个阶段是我们走向C/C++开发的进阶之路,更是一个让自己找份薪水比较体面的工作的筹码。

    如果在此部分遇到不懂的或者没有见过的知识点和名词,可先将本文收藏,供以后细细研读。

    那么这个阶段,我们又应该掌握什么呢,继续往下看:

    1.C++进阶之STL

    STL = Standard Template Library,即标准模板库。这是提高开发效率的极品工具。通过学习此阶段,应掌握泛型编程技巧,理解容器类在C++语言中的应用模式,以及熟练掌握全部STL类的使用方法。

    2.C++进阶之设计模式

    决定一个项目成败最重要的因素是项目总体的设计,通过本阶段的学习,可掌握面向对象编程中重要的一环,是编码前建模的技巧所在。单例模式;工厂模式;代理模式;迭代模式等,这些都是你要掌握的哦。

    3.C++进阶之数据结构基础

    这是所有编程语言中最应该学习的部分,程序组成的基础之一。

    顺序存储、链式存储、循环链表;

    双向链表、栈(顺序和链式)、队列(顺序和链式);

    栈的应用、树基本概念及遍历、二叉树;

    排序算法、并归算法、选择、插入、快速、希尔。

    4.C++进阶之UI界面开发

    掌握QT类库构架,图形界面开发模型;

    掌握QT开发技巧,消息机制,图形处理;

    掌握QT网络编程,UDP,TCP使用方式;

    掌握QT文件处理方式,序列化;

    掌握QT在windows,linux,ios,android不同平台下的移植技术。

    5.C++进阶之Unix/Linux网络服务器

    掌握Unix/Linux平台开发方式;

    熟练使用系统调用;

    熟练Unix/Linux内存管理,进程,线程调度;

    熟悉网络服务器开发方式,熟练编写TCP,UCP网络服务程序;

    掌握同步/异步IO模型在网络编程中的使用方式。

    ⑥ C++进阶之数据库开发

    掌握SQL语言的实用技巧。Oracle,MySQL数据库的使用方式。

    如果你能熟练掌握以上列出的技能,具备解决复杂问题和技术难点的能力,而且你能独立开发一些比较复杂的功能模块,那么很荣幸地告诉你,你已经达到中级水平,薪资过万对你来说简直是小菜一碟。

    C++开发高级
    读到此处的你,相信你有更高的目标。即是当下炙手可热的全栈开发工程师,既晓前端,又通后台。快速定位问题,解决问题对他们来说已是小菜一碟,就是人们常说的神秘大牛,只在公司技术攻关的时候才会才看到他们的身影。

    ①此阶段软件开发工作所需的知识和技能相对较难,高级软件工程师编码熟练度和规范性需要达到一定要求;

    ②具备一定的项目能力(包括调试能力、文档编写能力、测试能力等)和综合技术素质(包括对软件生命周期的理解、对设计模式的理解、必备的行业知识和经验等);.

    ③了解主流的后台技术和前后端协作方式,能从全局角度理解项目的整个生命周期。

    如果你能熟练掌握以上三个阶段的知识技能,那么你就可以满足C++开发行业的高级需求。

    配套视频:
    http://www.makeru.com.cn/course/1861.html?s=143793

    展开全文
  • task1-数组理论部分数组的定义数组的存储的特点定义数组的格式静态数组和动态数组静态数组动态数组数组练习利用动态数组存放数据托普利茨矩阵判断三数之和问题 理论部分 数组的定义 数组是具有一定顺序关系的若干...

    理论部分

    数组的定义

    数组是具有一定顺序关系的若干对象的集合,组成数组;特点:一定是同一数据类型,这是和C语言中结构体最大的不同;数组名是该数组的首地址;下标代表着对应元素的序号(从0开始)

    数组的存储的特点

    1. 数组元素在内存中连续存储;
    2. 数据的分配按照行(例如C,C++)先来分配;按列先来分配(fortune);
    3. 数组名表示数组的首地址是常量;

    数组在内存存储方式

    定义数组的格式

    int[] a = new int[10] 一维数组(向量) 类比:线
    int[ , ] a = new int[2,3] 二维数组(矩阵) 类比: 面
    int[ , , ] a = new int[2,3,4] 三维数组(体) 类比:体 ,书本(第2页,第3行,第4列)
    数组基本90%以上都是这这三维数组,深刻的掌握这三维数组就够了;

    静态数组和动态数组

    静态数组

    在程序运行前分配好空间的数组;静态数组声明之后数组长度不变

    动态数组

    在程序运行时彩分配空间的数组;数组长度可根据用户的需求可变

    数组练习

    利用动态数组存放数据

    1. 代码部分
    // 动态申请数组存放数据
    /*
      要求:输入一个N,用动态数组存放所有2--N之间的所有5或者7的倍数并输出
      语言:使用C语言
      难点:怎么用C语言创建动态数组
      解决:利用malloc申请动态数组,并最后free掉,释放内存
      反思:复习C语言指针;malloc和free用法;
    */
    #include <stdio.h>
    #include <stdlib.h>
     
    int main(){
        int arrLen;  // 数组长度
        int *array;  // 数组指针
        int i;  // 数组下标
     
        printf("输入数组长度:");
        scanf("%d", &arrLen);
        
        // 动态分配内存空间,如果失败就退出程序
        array = (int*) malloc( arrLen*sizeof(int) );
        if(!array){
            printf("创建数组失败!\n");
            exit(1); 
        }
        // 向数组写入数据
        for(i=0; i<arrLen-1; i++){      // 就用这种编程风格习惯,非常好用
            array[i] = i+2;
        }
        array[arrLen-1] = 1;   
        
    	// 输出想要的数组元素
        for(i=0; i<arrLen; i++){
    		if(array[i] % 5 ==0 || array[i] % 7 ==0){
    			 printf("%d  ", array[i]);
    		}
           
        }
        
        printf("\n");
        free(array); 
        
        system("pause");
        return 0;
    }
    
    
    1. 测试结果
      数组长度为100的测试结果

    托普利茨矩阵判断

    1.代码部分

    // 托普利茨矩阵问题
    /*
      要求:给定一个输入的M X N矩阵,判断真假并返回
      描述:什么是托普利茨矩阵,每一个对角线都是一样的
      语言:C语言
      难点:1. 不会用C语言申请动态二维数组,指针看着有点头晕
    		2. 没有想出来判断的依据,递归思想;
      反思:复习指针;
      
    */
    
    
    #include <stdio.h>
    #include <stdlib.h>
     
    int main(){
        int row , col;  // 数组长度
        int **array;  // 数组指针
        int i,j;  // 数组下标
     
        printf("输入数组行数和宽度:");
        scanf("%d %d", &row,&col);
        
        // 动态分配内存空间,如果失败就退出程序
        array = (int**)malloc( row * sizeof(int*) );  // 开辟行
    	for(i=0;i<col;i++){
    		*(array+i) = (int*)malloc(sizeof(int) * col); //开辟列
    	
    	}
        if(!array){
            printf("创建数组失败!\n");
            exit(1); 
        }
      
        
        // 循环输入数组元素
    	printf("请输入数组元素:");
        for(i = 0 ; i < row;i++){
    		for(j = 0; j < col;j++){
    			scanf("%d",&array[i][j]);
    		}
    			
    	}
    	printf("输出数组矩阵:\n");
    	// 输出数组元素
    	for(i = 0 ; i < row;i++)
    	{
    		for(j = 0; j < col;j++)
    		{
    		   printf("%3d ",array[i][j]);
    		}
    		printf("\n");
    	}
    
    	// 进行判断是否为托普利茨矩阵
    	int count = 0;
    	for(i = 0 ; i < row;i++)
    	{
    		for(j = 0; j < col;j++)
    		{
    			if(!(i==0||j==0||array[i-1][j-1]==array[i][j])) {
    				count++;
    			}
    
    		}
    	
    	}
    
    	printf("是不是托普利茨矩阵:");
    	if(count==0){
    		printf("Yes \n");
    	}
    	else{
    		printf("No \n");
    	
    	}
    	   
        printf("\n");
    	// 释放开辟的内存
    
    	for(i = 0; i < row;i++){
    		free(*(array+i));
    	}
    	
        system("pause");
        return 0;
    }
    
    
    1. 测试部分
      测试结果

    三数之和问题

    1. 代码部分
    // 三数之和问题
    /*
      要求:给定一个包含n个整数的数组nums,判断nums数组中是否存在三个元素a,b,c
      使得a+b+c=0,找出这三个数;
      语言:C语言
    */
    
    #include <stdio.h>
    #include <stdlib.h>
     
    int main(){
        int arrLen;  // 数组长度
        int *array;  // 数组指针
        int i;  // 数组下标
     
        printf("输入数组长度:");
        scanf("%d", &arrLen);
        
        // 动态分配内存空间,如果失败就退出程序
        array = (int*)malloc( arrLen * sizeof(int) );
        if(!array){
            printf("创建数组失败!\n");
            exit(1); 
        }
        // 向内存中写入数据
    	printf("输入数组元素:");
        for(i=0; i<arrLen; i++){
            
    		scanf("%d", &array[i]);
        }
    
        printf("输入的数组为:\n");
    
        // 循环输出数组元素
    
        for(i=0; i<arrLen; i++){
            printf("%3d ", array[i]);
        }
    	printf("\n");
        int temp = 0;
    	// 用冒泡法对数组进行先排序
    	for(i=0;i < arrLen-1;i++) // 进行10次循环
    	{
    		for(int j=i+1;j < arrLen;j++) // 循环比较剩余的变量
    		{
    			if(array[i] > array[j]) // 如果前面一个数比后面数大,交换两个数的值
    			{
    				temp = array[i];
    				array[i] = array[j];
    				array[j] = temp;
    			}
    		}
    	}
    	
    	// 进行算法比较
    	printf("满足要求的三元数组:\n");
    	for(int m=0;m<arrLen;m++){
    		for(int n=2;n<arrLen;n++){
    			if(array[m]+array[m+1]>=0){
    				break;
    			}
    			else{
    				if(array[m]+array[m+1]+array[n]==0){
    					printf("%3d%3d%3d \n",array[m],array[m+1],array[n]);
    				}
    			
    			}
    		}
    	
    	}
    
    
        printf("\n");
        free(array); 
        
        system("pause");
        return 0;
    }
    
    
    1. 测试部分
      测试结果
      以上即为理论和实践部分,希望对大家有所帮助
    展开全文
  • 1、基本定义sizeof():首先sizeof()在c语言中是一种单目运算符,在编译的时候就进行计算,它的作用是用来计算出对象所占的字节数,通常用来查看变量、数组或结构体等所占的字节个数。其中对象的字节个数具体的操作...

    1、基本定义

    sizeof():

    首先sizeof()在c语言中是一种单目运算符,在编译的时候就进行计算,它的作用是用来计算出对象所占的字节数,通常用来查看变量、数组或结构体等所占的字节个数。其中对象的字节个数与具体的操作平台有直接的关系。

    括号里的参数可以是数组、指针、类型、对象、函数等。

    而且它不能用来返回动态分配的内存空间的大小。实际上,用sizeof来返回类型以及静态分配的对象、结构或数组所占的空间,返回值跟对象、结构、数组所存储的内容是没有关系。具体语法及举例在后面附着。

    strlen():

    strlen()是函数,要在运行时才计算,它的作用返回字符串的长度。该字符串可以是自己定义的,也可能是内存中随机的,该函数实际完成的功能是从代表该字符串的第一个地址开始遍历,直到遇到结束符NULL。返回的长度大小不包括NULL。

    括号里的参数必须是字符型指针(char *)。当数组名作为参数传入时,实际上数组就退化成指针了。

    2、具体的语法及举例

    sizeof()有三种语法形式,如下:
    1) sizeof ( object ) ;     // sizeof( 对象 ) ;   sizeof ( i );

    2) sizeof  ( type_name );    //   sizeof( 类型 ) ;   sizeof ( int );    sizeof   int ;

    3) sizeof object;     // sizeof 对象 ;  sizeof  i ;

    char * str1 = "jl"; 解析:str1在这里是指针,在这里不是指字符串占的空间,而是一个字符型指针所占的空间,指针占4个字节。

     sizeof (str1) = 4.  =>  sizeof (str1) =sizeof (char *)=4.

    char  str2[ ]= "jl"; 解析:str2是字符型数组,对于数组而言,返回的是这个数组所占的总的空间,数组的屁股后面还跟有'\0'。

    sizeof (str2) = 3. => sizeof (str2) => { j , l , \0}=3.

    char  str3 [ 8 ]= {'j',}; 解析:str3是定义了长度为8的数组。因此 sizeof (str3) = 8.

    char  ss[ ] = "012345" ; 解析:这个类似于第二种情况。sizeof ( ss )= 7 => sizeof ( ss )= {0 , 1 ,2, 3, 4, 5, \0}=7.

    在这里,重点提出对于指针,sizeof()返回的是该指针所占的空间,一般为4个字节。但是对于数组而言,返回数组所有元素占的总空间,(包括'\0').特别地对于结构体而言,sizeof()要满足字节对齐。字节对齐就是结构体的总大小为结构体最宽基本类型成员大小的整数倍。而且空结构体的sizeof()为1,不是0.

    对于strlen()不区分是数组还是指针,就读到\0为止返回长度。而且strlen是不把\0计入字符串的长度的.

    strlen()源代码如下:

    #include<stdio.h>

    方法一、利用中间变量(计数)

    int strlen (const char * str)
    {
    int i=0;
    while((str[i])!='\0')
    {
    ++i;
    }
    return i;
    }
    void main()
    {
    char * s="hello";
    printf("%d \n",strlen(s));

    }

    方法二、不借助计数变量

    int strlen (const char * str)
    {
    if( NULL == str) return NULL;
    else 
    return (*str!='\0') ? (1+strlen(str+1)) : 0;
    }
    void main()
    {
    char * s="hello";
    printf("%d \n",strlen(s));

    }

    方法三、利用指针的加减法

    int strlen ( char * str)
    {
    char * p = str;
    while(*p!='\0')

    {p++;}

    return p - str ;
    }
    void main()
    {
    char * s="hello";
    printf("%d \n",strlen(s));
    }

    欢迎读者批评指正。

    展开全文
  • 实际上使用sizeof来返回类型以静态分配的对象结构体、数组的空间,返回值和其内容没有关系。 strlen strlen是计算字符串的长度,以‘ \0 ’为字符串的结束标志。返回从第一个地址开始到‘ \0 ...
  • 有人说:“C生万物,编程之本”,这一点都没有错! C语言是最接近计算机的语言,很多时间,我们都会发现,C语言是非常有必要学习的。...●类的封装,构造和析构、静态成员、对象管理; ●类的...
  • 78.9.1 动态存储方式与静态动态存储方式 120 8.9.2 auto变量 120 8.9.3 用static 声明局部变量 121 8.9.4 register 变量 122 用extern 声明外部变量 123 9 预处理命令 9.1 概述 124 9.2 宏定义 125 9.2.1 无参宏定义...
  • 1. 闭包定义 ...一个函数类型就像结构体一样,可以被实例化,函数本身不存储任何信息,只有引用环境结合后形成的闭包才具有“记忆性”,函数是编译期静态的概念,而闭包是运行期动态的概念。** 2. ...
  • 78.9.1 动态存储方式与静态动态存储方式 120 8.9.2 auto变量 120 8.9.3 用static 声明局部变量 121 8.9.4 register 变量 122 用extern 声明外部变量 123 9 预处理命令 9.1 概述 124 9.2 宏定义 125 9.2.1 无参宏定义...
  • 静态初始化线程时,线程结构体与线程的栈,必须是【全局变量】 我当时没在意,静态初始化线程时,线程结构体使用函数内的局部变量,编译通过了,运行就死机。 死机原因hardfault,bus fault,不过,经过耐心的分析...
  • 面试主要分两部分 一、图像处理算法相关项目经验 ...2、静态数组与动态数组的区别; 3、一个结构体,有int,char, float它的对象.size()是多大? 4、static加在变量上和加在函数之前有什么作用? ...
  • 43. 内存对齐的原则? A.结构体的大小为最大成员的整数倍。 B.... 44. 内联函数宏定义的...45. 动态分配对象静态分配对象的区别? 动态分配就是用运算符new来创建一个类的对象,在堆上分配内存。 静态分配就是A a,
  • c++ 程序设计

    2019-01-20 22:53:37
    12.3.2 静态关联与动态关联 12.3.3 在什么情况下应当声明虚函数 12.3.4 虚析构函数 12.4 纯虚函数与抽象类 12.4.1 纯虚函数 12.4.2 抽象类 12.4.3 应用实例 习题 第13章 输入输出流 13.1 C++的输入和输出 13.1.1 ...
  • 16.3 Linux系统下创建并使用静态与动态库 390 16.3.1 Linux系统下创建并使用静态库文件 390 16.3.2 Linux系统下创建并使用动态库 391 16.4 本章小结 393 第四篇 语法扩展篇 第17章 GCC对C11标准的语法扩展 /...
  • C语言程序设计(高清PDF)

    千次下载 热门讨论 2010-12-27 16:54:09
    10.3.1 类的定义与对象的引用 209 10.3.2 构造函数析构函数 211 10.3.3 函数重载 215 10.3.4 友元 216 10.4 对象指针 219 10.5 派生类继承类 225 10.5.1 单继承的派生类 225 10.5.2 多继承的派生类 233 附录A ...
  • 10.3.1 类的定义与对象的引用 209 10.3.2 构造函数析构函数 211 10.3.3 函数重载 215 10.3.4 友元 216 10.4 对象指针 219 10.5 派生类继承类 225 10.5.1 单继承的派生类 225 10.5.2 多继承的派生类 233 附录A ...
  • 10.3.1 类的定义与对象的引用 209 10.3.2 构造函数析构函数 211 10.3.3 函数重载 215 10.3.4 友元 216 10.4 对象指针 219 10.5 派生类继承类 225 10.5.1 单继承的派生类 225 10.5.2 多继承的派生类 233 附录A ...
  • C语言程序设计.rar

    2009-09-28 13:44:30
    10.3.1 类的定义与对象的引用 209 10.3.2 构造函数析构函数 211 10.3.3 函数重载 215 10.3.4 友元 216 10.4 对象指针 219 10.5 派生类继承类 225 10.5.1 单继承的派生类 225 10.5.2 多继承的派生类 233 附录A ...
  • 9.7 对象动态建立和释放 9.8 对象的赋值和复制 9.9 静态成员 9.10 友元 9.11 类模板 第10章 运算符重载 10.1 什么是运算符重载 10.2 运算符重载的方法 10.3 重载运算符的规则 10.4 运算符重载函数作为类...
  • 疯狂ios讲义源代码

    千次下载 热门讨论 2014-01-02 09:12:50
    4.2.4 动态存储与静态存储 99 4.3 预处理 101 4.3.1 使用#define、#undef执行宏定义 101 4.3.2 带参数的宏定义 103 4.3.3 使用#ifdef、#ifndef、#else、#endif执行条件编译 104 4.3.4 使用#if、#elif、#else、#...
  • 1、动态调式工具及静态分析工具 2、汇编基础知识学习 3、通过一个简单的程序讲解VC6.0调式器 4、C++中基础数据类型 5、了解C++ 启动函数及OD中定位main函数 6、C++ 基本表达式的识别 7、除法模运算的识别 8、...
  • 6.3.2 动态内存分配释放函数191 6.4 深拷贝浅拷贝191 6.5 字符串195 6.5.1 用字符数组存储和处理字符串195 6.5.2 string类198 6.6 程序实例——人员信息管理程序200 6.7 小结204 习题204 第7章 继承...
  • 8.4.6 对象在栈堆中的不同 107 8.5 this指针 109 8.6 指针的常见错误 110 8.7 指针运算 112 8.7.1 指针的加减运算 112 8.7.2 指针的赋值运算 113 8.7.3 指针的相减运算 114 8.7.4 指针的比较运算 114 8.8 ...
  • 18.3.1 动态存储方式和静态存储方式 191 18.3.2 auto变量 192 18.3.3 用static声明局部变量 192 18.3.4 register变量 194 18.3.5 用extern声明外部变量 196 18.3.6 用static声明外部变量 198 18.3.7 关于变量...
  • 8.1 字符大对象:CLOBNCLOB数据类型 242 8.2 PL/SQL读文件写CLOB或NCLOB列 246 8.3 向数据库中上传CLOB 249 8.4 二进制大对象:BLOB数据类型 250 8.5 PL/SQL读文件写BLOB列 252 8.6 向数据库中上传BLOB ...
  • 0063 数据类型对象大小的区别 26 0064 实现类的强制转换 26 1.8 高级函数 27 0065 如何重载操作符 27 0066 如何定义重载函数 28 0067 默认构造函数 28 0068 复制构造函数 28 0069 this指针分析 ...

空空如也

空空如也

1 2 3 4
收藏数 71
精华内容 28
关键字:

结构体静态与动态对象