精华内容
下载资源
问答
  • C程序查找错误的方法

    千次阅读 2012-07-20 20:18:58
    它一般在编译后显示为段错误,而段错误不像其它语法错误,编译器会自动提示你错误在哪一行,在这里就不详提出现段错误的原因有哪些,主要是讲讲一些查找错误的方法,不过提醒下大部分还是因为内存的不合理使用造成...

              在linux系统中我们写C语言应用程序经常会遇到让编译器不能找出来的错误,它一般在编译后显示为段错误,而段错误不像其它语法错误,编译器会自动提示你错误在哪一行,在这里就不详提出现段错误的原因有哪些,主要是讲讲一些查找段错误的方法,不过提醒下大部分还是因为内存的不合理使用造成的,而C语言在使用内存时一般都是用指针,所以说在写C程序时用指针时一定要小心。下面我就介绍几种比较常用的方法来查找段错误:

    方法1:printf的使用

    使用printf函数,就是在出现段错误后在你认为会有错误的地方用printf函数随便打印一句话,如果编译后能够看到你写的那句话,那就说明出现段错误的地方在那句printf函数后面,然后接着在后面使用printf函数,直到你要printf打印的那句话在编译后没有打印出来,说明那个出现段错误的地方在printf函数上面。以此方法可以很方便的找出出现段错误的那行代码。这种方法只适合代码少的程序,如果代码很多的话,这种方法就显得非常慢了。


    方法2:gdb之动态符号-rdynamic

    通过GDB调试工具查找,可以快速方便的查找出现段错误的地方。在此我编写了一个由于指针没有分配内在就使用而导致的段错误的示例test.c:

    #include<stdio.h>
    int main()
    {
    int a;
    int *p=&a;
    int *q;
    *p=5;
    printf("p=%d\n",*p);
    *q=7;
    printf("q=%d\n",*q);
    }

    然后利用gcc编译:[root@localhost test]# gcc test.c -o test -g -rdynamic

    然后用gdb调试:[root@localhost test]# gdb test

    GNU gdb (GDB) Red Hat Enterprise Linux (7.0.1-23.el5)
    Copyright (C) 2009 Free Software Foundation, Inc.
    License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
    This is free software: you are free to change and redistribute it.
    There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
    and "show warranty" for details.
    This GDB was configured as "i386-redhat-linux-gnu".
    For bug reporting instructions, please see:
    <http://www.gnu.org/software/gdb/bugs/>...
    Reading symbols from /home/test/test...done.
    (gdb) 

    输入命令:r 

    运行后出现(gdb) r
    Starting program: /home/test/test 
    p=5
    Program received signal SIGSEGV, Segmentation fault.
    0x0804853c in main () at 1.c:9
    9           *q=7;
    (gdb)

    我们可以发现出现段错误的地方是第9行代码。分析代码可知指针q出现错误而p没有错误是出于q没有分配内存。 注意:在编译test.c时参数-g 和 -rdynamic 不能少,其中-g 是用来gdb调试的,-rdynamic是用来通知链接器将所有符号添加到动态符号表中。

    方法3:gdb之core文件

               用命令:ulimit -c unlimit,产生core文件,就是程序运行发行段错误时的文件。我们就继续拿上面的示例代码来说吧,首先输入以下命令: ulimit -c unlimit

    接下来的看以下操作:

    [root@localhost test]#gcc test.c -o test -g

    [root@localhost test]# ls
    test.c  core.18161  test

    在这里我们发现已经生成了core文件,接下来利用它们调试:
    [root@localhost test]# gdb test core.18161 
    GNU gdb (GDB) Red Hat Enterprise Linux (7.0.1-23.el5)
    Copyright (C) 2009 Free Software Foundation, Inc.
    License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
    This is free software: you are free to change and redistribute it.
    There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
    and "show warranty" for details.
    This GDB was configured as "i386-redhat-linux-gnu".
    For bug reporting instructions, please see:
    <http://www.gnu.org/software/gdb/bugs/>...
    Reading symbols from /home/test/test...done.
    Reading symbols from /lib/libc.so.6...(no debugging symbols found)...done.
    Loaded symbols for /lib/libc.so.6
    Reading symbols from /lib/ld-linux.so.2...(no debugging symbols found)...done.
    Loaded symbols for /lib/ld-linux.so.2
    Core was generated by `./test'.
    Program terminated with signal 11, Segmentation fault.
    #0  0x080483bc in main () at 1.c:9
    9           *q=7;
    (gdb) 

    我们发现在输入:gdb test core.18161命令后直接跳到了*q=7的这一行,而这一行也正是出现段错误的代码行。

            GDB工具是一个不错的调试工具,利用好了它在以后的调试工作上可以事半功倍。








    展开全文
  • Word常用查找与替换实例及方法 可以大幅提高排版效率! 不看绝对后悔,建议下了留着备用 另:别人写,不记得从哪里下了: 目录 Word查找与替换•ASCII字符集代码 I Word查找栏代码•通配符一览表 II Word...
  • IDEA查找接口实现类: ctrl + alt +B (这快捷键。不想说啥。相当于eclipse:ctrl +T) IDEA快速实现接口: Alt + Shift + P (这个很常用了吧,基本上一实现接口就得用) Get/Set方法快捷键:Alt + Insert ...

    IDEA查找接口的实现类: ctrl + alt +B (这快捷键。不想说啥。相当于eclipse:ctrl +T)

    IDEA快速实现接口: Alt + Shift + P (这个很常用了吧,基本上一实现接口就得用)

    Get/Set方法快捷键:Alt + Insert

    自动补全返回值类型的快捷键:Ctrl + Alt+ V

    自动显示错误决绝方案快捷键:Alt+Enter (注意事项,如下图)


    快速生成语句快速生成Main()方法: psvm + 回车 (老铁,是不是更习惯main+Alt+/ ?)

    快速生成输出语句: sout + 回车 (其实我想说我也喜欢syso,Alt+/ )

    内容提示,代码补全键:Ctrl+Alt+space(我知道你不知道space是啥键,我知道你英文水平和我一样,悄悄告诉你个秘密,那是空格键)

    格式化代码:Ctrl+Alt+L

    查找所有,你没看错是所有:Shift + Shift

    自由切换:Ctrl+Tab

    删除整行:Ctrl+X

    重构快捷键:Ctrl+Shift+Alt+T
     

    展开全文
  • Matlab的常用调试方法

    2019-09-24 09:17:43
    因为它没有指针概念,这样就避免了一大类难以查找的错误。 不过,M程序可能会经常出现索引错误,如果设置了 stop if error( Breakpoint 菜单下),则程序执行会停在出错位置,并在MATLAB命令行窗口显示出错...

         M程序调试器的热键设置和VC的设置有些类似,如果用户有其他语言的编程调试经验,则调试M程序显得相当简单。因为它没有指针的概念,这样就避免了一大类难以查找的错误。

         不过,M程序可能会经常出现索引错误,如果设置了 stop if error( Breakpoint 菜单下),则程序的执行会停在出错的位置,并在MATLAB命令行窗口显示出错信息。下面列出了一些常用的调试方法。

       (1)设置或清除断点:使用快捷键F12;

       (2)执行:使用快捷键F5;

       (3)单步执行:使用快捷键F10;

       (4)step in:当遇见函数时,进入函数内部,使用快捷键F11;

       (5)step out:执行流程跳出函数,使用快捷键 “shift + F11”;

       (6)执行到光标所在位置:非常遗憾这项功能没有快捷键,只能使用菜单来完成这样的功能;

       (7)观察变量或者表达式的值:将鼠标放在要观察的变量上停留片刻,就会显示出变量的值,当矩阵太大时,只显示矩阵的维数;

       (8)退出调试模式:没有设置快捷键,使用菜单或者快捷按钮来完成;

    转载于:https://www.cnblogs.com/571328401-/p/11470337.html

    展开全文
  • java中常用的排序和查找算法

    千次阅读 2017-10-09 16:55:13
    java中的常用排序方法java中常用的几种排序方法:选择排序、插入排序、快速排序、冒泡排序、归并排序、shell排序。 java 中的查找方法有:顺序查找法、二分查找法选择排序思路:在乱序数组中,假设第一位数最小,...

    本文内容来自网络资源整理,若有错误,敬请指正。

    java中的常用排序方法

    java中常用的几种排序方法:选择排序、插入排序、快速排序、冒泡排序、归并排序、shell排序。
    java 中的查找方法有:顺序查找法、二分查找法

    选择排序

    思路:在乱序数组中,假设第一位数最小,依次让后面的数与之比较,若遇到比它小的数就交换位置,一趟下来第一个数就是序列中最小的数,然后从第二个数开始重复操作。

        public static void selectSort(int[] array) {  
            int position = 0;  
            for (int i = 0; i < array.length; i++) {  
                int j = i + 1;  
                position = i;  
                int temp = array[i];  
                for (; j < array.length; j++) {  
                    if (array[j] < temp) {  
                        temp = array[j];  
                        position = j;  
                    }  
                }  
                array[position] = array[i];  
                array[i] = temp;  
            }  
            System.out.println(Arrays.toString(array) + " selectSort");  
        }  
    插入排序

    思路:如同玩扑克牌一样,每次摸牌都将它与手中的牌比较,始终将牌放在比它大的牌前面,比它小的牌后面。这样当牌全部摸到手上后,就是一个有序的序列。

    public static void insertSort(int[] array) {  
         for (int i = 1; i < array.length; i++) {  
             int temp = array[i];  
             int j = i - 1;  
             for (; j >= 0 && array[j] > temp; j--) {  
                 //将大于temp的值整体后移一个单位  
                 array[j + 1] = array[j];  
             }  
             array[j + 1] = temp;  
         }  
         System.out.println(Arrays.toString(array) + " insertSort");  
     }  
    shell排序

    希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
    希尔排序是基于插入排序的以下两点性质而提出改进方法的:
    插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;
    但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。
    先取一个正整数d1 < n, 把所有相隔d1的记录放一组,每个组内进行直接插入排序;然后d2 < d1,重复上述分组和排序操作;直至di = 1,即所有记录放进一个组中排序为止。

    shell

        public static void shellSort(int[] array) {  
            int i;  
            int j;  
            int temp;  
            int gap = 1;  
            int len = array.length;  
            while (gap < len / 3) { gap = gap * 3 + 1; }  
            for (; gap > 0; gap /= 3) {  
                for (i = gap; i < len; i++) {  
                    temp = array[i];  
                    for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {  
                        array[j + gap] = array[j];  
                    }  
                    array[j + gap] = temp;  
                }  
            }  
            System.out.println(Arrays.toString(array) + " shellSort");  
        }  
    冒泡排序

    思路:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。
    代码:

        public static void bubbleSort(int[] array) {  
            int temp = 0;  
            for (int i = 0; i < array.length - 1; i++) {  
                for (int j = 0; j < array.length - 1 - i; j++) {  
                    if (array[j] > array[j + 1]) {  
                        temp = array[j];  
                        array[j] = array[j + 1];  
                        array[j + 1] = temp;  
                    }  
                }  
            }  
            System.out.println(Arrays.toString(array) + " bubbleSort");  
        }  
    快速排序

    快速排序是排序方法里面速率最快的一种方法,是对冒泡排序的一种改进, 属于不稳地排序。
    快速排序图

    public static void quickSort(int[] array) {  
        _quickSort(array, 0, array.length - 1);  
        System.out.println(Arrays.toString(array) + " quickSort");  
    }  
    
    
    private static int getMiddle(int[] list, int low, int high) {  
        int tmp = list[low];    //数组的第一个作为中轴  
        while (low < high) {  
            while (low < high && list[high] >= tmp) {  
                high--;  
            }  
    
    
            list[low] = list[high];   //比中轴小的记录移到低端  
            while (low < high && list[low] <= tmp) {  
                low++;  
            }  
    
    
            list[high] = list[low];   //比中轴大的记录移到高端  
        }  
        list[low] = tmp;              //中轴记录到尾  
        return low;                  //返回中轴的位置  
    }  
    
    
    private static void _quickSort(int[] list, int low, int high) {  
        if (low < high) {  
            int middle = getMiddle(list, low, high);  //将list数组进行一分为二  
            _quickSort(list, low, middle - 1);      //对低字表进行递归排序  
            _quickSort(list, middle + 1, high);      //对高字表进行递归排序  
        }  
    } 
    归并排序

    思路:归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
    归并排序

    代码:

        public static void mergingSort(int[] array) {  
            sort(array, 0, array.length - 1);  
            System.out.println(Arrays.toString(array) + " mergingSort");  
        }  
    
        private static void sort(int[] data, int left, int right) {  
            if (left < right) {  
                //找出中间索引  
                int center = (left + right) / 2;  
                //对左边数组进行递归  
                sort(data, left, center);  
                //对右边数组进行递归  
                sort(data, center + 1, right);  
                //合并  
                merge(data, left, center, right);  
            }  
        }  
    
        private static void merge(int[] data, int left, int center, int right) {  
            int[] tmpArr = new int[data.length];  
            int mid = center + 1;  
            //third记录中间数组的索引  
            int third = left;  
            int tmp = left;  
            while (left <= center && mid <= right) {  
                //从两个数组中取出最小的放入中间数组  
                if (data[left] <= data[mid]) {  
                    tmpArr[third++] = data[left++];  
                } else {  
                    tmpArr[third++] = data[mid++];  
                }  
            }  
    
            //剩余部分依次放入中间数组  
            while (mid <= right) {  
                tmpArr[third++] = data[mid++];  
            }  
    
            while (left <= center) {  
                tmpArr[third++] = data[left++];  
            }  
    
            //将中间数组中的内容复制回原数组  
            while (tmp <= right) {  
                data[tmp] = tmpArr[tmp++];  
            }  
        }  
    shell排序

    希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
    希尔排序是基于插入排序的以下两点性质而提出改进方法的:
    插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;
    但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。
    先取一个正整数d1 < n, 把所有相隔d1的记录放一组,每个组内进行直接插入排序;然后d2 < d1,重复上述分组和排序操作;直至di = 1,即所有记录放进一个组中排序为止。

    shell排序

    代码:

        public static void shellSort(int[] array) {  
            int i;  
            int j;  
            int temp;  
            int gap = 1;  
            int len = array.length;  
            while (gap < len / 3) { gap = gap * 3 + 1; }  
            for (; gap > 0; gap /= 3) {  
                for (i = gap; i < len; i++) {  
                    temp = array[i];  
                    for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {  
                        array[j + gap] = array[j];  
                    }  
                    array[j + gap] = temp;  
                }  
            }  
            System.out.println(Arrays.toString(array) + " shellSort");  
        }  

    查找算法

    java中常用的查找算法有顺序查找和二分查找。顺序查找也许效率较低,二分查找效率高,但是要在序列是在有序的情况下。顺序查找这里不在赘述。

    二分查找

    前提条件:已排序的数组中查找

    二分查找的基本思路是:首先确定该查找区间的中间点位置: int mid = (low+upper) / 2;然后将待查找的值与中间点位置的值比较:若相等,则查找成功并返回此位置。若中间点位置值大于待查值,则新的查找区间是中间点位置的左边区域。若中间点位置值小于待查值,则新的查找区间是中间点位置的右边区域。下一次查找是针对新的查找区间进行的。

    图例说明:

    原始数据: int[] a={5,3,6,1,9,8,2,4,7}; 查找是否存在数字8;

    第一步,先用之前学过的排序方法将数组按升序排序:int[] a={1,2,3,4,5,6,7,8,9};

    第二步,取中间数:5跟8比较,8大于5 ,取中间数右侧的数组进行比较,即{6,7,8,9}

    第三步:重复第一步和第二步,直到找到数据或者比较完所有数据。

    代码:

    import java.util.Scanner;
    /*
     * 二分查找
     */
    public class BinarySearch {
        public static void main(String[] args) {
            int[] arr={5,3,6,1,9,8,2,4,7};
            //先打印输出原始数组数据
            System.out.println("原始数组数据如下:");
            for (int n : arr) {
                System.out.print(n+" ");
            }
            System.out.println();
            //首先对数组进行排序,这里用冒泡排序
            for(int i=0;i<arr.length-1;i++){
                for(int j=0;j<arr.length-1-i;j++){
                    if(arr[j]>arr[j+1]){
                        int temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                }
            }
            //遍历输出排序好的数组
            System.out.println("经过冒泡排序后的数组:");
            for(int n:arr){
                System.out.print(n+" ");
            }
            System.out.println();//换行
            Scanner input=new Scanner(System.in);
            System.out.println("请输入你要查找的数:");
            int num=input.nextInt();
            int result=binarySearch(arr, num);
            if(result==-1){
                System.out.println("你要查找的数不存在……");
            }
            else{
                System.out.println("你要查找的数存在,在数组中的位置是:"+result);
            }
        }
        //二分查找算法
        public static int binarySearch(int[] arr,int num){
    
            int low=0;
            int upper=arr.length-1;
            while(low<=upper){
                int mid=(upper+low)/2;
                if(arr[mid]<num){
                    low=mid+1;
                }
                else if(arr[mid]>num){
                    upper=mid-1;
                }
                else
                    return mid;
            }
            return -1;
        }
    }
    展开全文
  • 查找有两种方法 1、下标查找数据 示例: # 1、下标查找数据 name_list = ['abc', 'liming', 'lily'] print(name_list[0]) print(name_list[1]) print(name_list[2]) 结果: 2、查找数据函数 index() 语法:列表...
  • 解决bug问题,查找bug的方法

    千次阅读 2020-07-08 14:32:35
    2、二分法定位,把可疑的代码分成两份,注释掉一半,再把错误的一半又分成两份,不断进行排错 3、输出日志,logger.info(“XXX”),就算程序出现错误,只要程序走到那里就可以看到输出的日志 4、Print输出可能有...
  • 哈希表及处理冲突的常用方法

    千次阅读 2018-04-04 18:18:49
    内容会持续更新,有错误的地方欢迎指正,谢谢! 前言 哈希法又称散列法,相应的表称为哈希表或散列表。 基本思想: 先在元素的关键字k和元素的存储位置p之间建立一个对应关系H,使得p=H(k),H称为哈希函数。...
  • index()方法,返回查找第一个下标,如果找不到查找值,则抛出错误。insert()方法,插入对象到指定下标后面。 pop()方法,弹出列表指定下标元素。不指定下标时,弹出最后一个元素。remove(...
  • 曾经我刚开始学习 shell 脚本时,除了知道用 echo 输出一些信息外,并不知道其他方法,仅仅依赖 echo 来查找错误,比较难调试且过程繁琐、效率低下。本文介绍下我常用的一些 shell 脚本调试方法,希望能对 shell ...
  • 最近在用,记录一下,如果有错误还请指正。 WebDriver 用对应浏览器driver类初始化对象。 WebDriver driver=new FirefoxDriver();...findElement()方法查找页面内元素。返回WebElement对象。 不同参数对应...
  • JAVA字符串String常用操作String str1 = “ABCabc”; String str2 = “abcabc”;...str1.indexOf(“abc”) //从左至右查找"abc"字符串在str1中第一次查找位置,如果没有查找到返回-1; str1.replace(“AB
  • 写程序遇到 Bug 并不可怕,大部分问题,通过简单 Log 或者 ...这篇文章,给大家介绍一个常用的查找 EXC_BAD_ACCESS 问题根源的方法。  首先说一下 EXC_BAD_ACCESS 这个错误,可以这么说,90%的错误来源在于对

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 781
精华内容 312
关键字:

查找错误的常用方法