精华内容
下载资源
问答
  • Int类型使用纪要

    2020-07-24 16:33:32
    * Int类型使用纪要: * * Java虚拟机在对Int类型的数据进行处理的时候,有两条默认的规则: * 1. 当程序中出现“整型常量”的时候,默认会以int类型处理; * 2. 如果算数表达式中出现的所有整形常量(数字)都...
    /**
     * Int类型使用纪要:
     *
     * Java虚拟机在对Int类型的数据进行处理的时候,有两条默认的规则:
     *  1. 当程序中出现“整型常量”的时候,默认会以int类型处理;
     *  2. 如果算数表达式中出现的所有整形常量(数字)都是int类型,默认的运算结果也是int类型;
     *
     *  注意:
     *      需要注意一点:在程序编辑过程中,编译器只对直接出现的int常量进行超范围检查,
     *      但是对于在编译中算数运算、表达式产生的int型值则不会进行范围检查;
     */
    public class IntGo {
    
        /**
         * Java主函数|入口;
         *
         * 下面看一个示例:
         * @param args
         */
        public static void main(String[] args) {
    
            /**
             * 我们用”9999999999999999“给long类型的变量l赋值,其实”9999999999999999“这个值
             * 并没有超出long的大小。但是编译器认为这条赋值语句有语法错误,这是为什么呢?
             *
             * 我们一开始的时候说过,当程序中出现“整型常量”的时候,默认都是以int类型存储的。而”9999999999999999“
             * 就是直接出现的”整型常量“,所以编译器会把他当作int型看待。尽管它最总被赋值给了long类型。
             *
             * 刚才说过,编译器会对”直接出现“的int常量进行数据超范围的检查,而”9999999999999999“
             * 就是直接出现在程序中的,并且还被当作int整型数据来看待,所以编译器要对其进行检查,而
             * 经过检查这个数字已经超过了int类型所表示的范围,所以就会报错;
             *
             * 解决办法:
             *  修改这个错误的方法很简单,只需要在直接出现的整型常量“9999999999999999"这个数字后面加”L“
             *  即可解决这个问题;
             */

            /**
             * 2.
             * 上面说了,编译器会对直接出现的整型常量做超范围检查的操作,能够避免int类型数据超出范围存储-
             * 导致的数据丢失问题出现。
             * 但是对于编译器不报错的情况就需要注意了,下面就来说明一下:
             *
             * 就像下面的一个例子:
             */
    
            /**
             * 计算24小时共计多少微秒;
             * (1小时=60分钟)
             * (1分钟=60秒)
             * (1秒=1,000毫秒)
             * (1毫秒=1,000微秒)
             * (1微秒=1,000纳秒)
             * (1秒=1,000,000微秒)
             *
             * 根据上面的单位进制可以得到下面的公式:
             */
            long lTimeError = 24 * 60 * 60 * 1000 * 1000;
    
            /**
             * 上面的计算中,考虑到最终的计算结果会超出int类型的表示范围,在存储的时候很小心的把计算结果保存在
             * 了long类型的变量中。(正确计算结果:86,400,000,000)
             *
             * 但是运行结果却不尽然;
             * 如下图:
             */

     

            /**
             * 在这个算数运算中,所有出现的整型常量都会被编译器当作int类型的数据进行计算,并且上面的
             * 算数运算所有参与运算的常量都是int类型且没有任何一个参数常量出现超范围异常。
             * 那为什么最终的结果却出现了差池呢?
             * 在运算中,因为全部的数据都是int类型,所以每一步的运算结果都会被保存在一个int型的临时
             * 变量中,但是由于每一步的运算结果都不是“直接出现的数字”,因此编译器不会对每一步的结果
             * 进行超范围检查。
             * 最终的结果就是:随着常数值的越来越大,最终超出了int类型的表示范围。而编译器由于没有对
             * 其进行超范围检查,故而在压根不知道当前的这个结果会出现超出范围的情况下,把一个超范围的
             * 值赋给了int类型的临时变量,从而出现了“溢出”的现象;int类型取值时会将赋值超出范围的高位
             * 部分舍弃,只取了地位数据,最后得到的就是一个错误的结果;
             *
             * 所以在运算过程中,一定要考虑到运算结果对应的临时类型的取值范围;
             * 否则必定会出现运算结果超类型所能表示的最大范围导致“溢出”,最终取值错误的情况;
             *
             * 当然,解决这个问题的办法也很简单,只需要在运算没有超范围之前升一下对应的类型,增大临时类型
             * 能够存储的范围即可;
             *
             * 就上面的例子,可以在运算结果没有超范围之前升型(加L);
             * 
             * 如下图:
             */

     

            /**
             * 关于int类型还有一个问题,int类型最大能够表示的数是2147483647。
             * 如下图:
             */

     

            /**
             * 倘若以下面的方式循环,表面上看只能执行101次,但其实这是一个死循环;
             * 因为2147483647是int类型所能表示的最大的数,如果++1就会变成-2147483648;
             * 然后循环就会一直遍历,最终变成一个死循环;
             */

    展开全文
  • priority_queue<int>que;//参数为数据类型,(默认优先级-最大值优先)构造队列 如何控制优先级? 有4种方法可以实现对优先级的控制: 使用C++自带的库函数 自定义优先级A 自定义优先级B 自定义优先级C...

    普通队列是一种先进先出的数据结构,元素在队列尾追加,而从队列头删除。在优先队列中,元素被赋予优先级。当访问元素时,具有最高优先级的元素最先删除。
    优先队列具有最高级先出的行为特征。优先队列是0个或多个元素的集合,每个元素都有一个优先权或值。
    对优先队列执行的操作:

    • 查找
    • 插入一个新元素
    • 删除

    在最小(大)优先队列中,查找操作用来搜索优先权最小(大)的元素,删除操作用来删除该元素。优先队列中的元素可以有相同的优先权,查找与删除操作可以根据任意优先权进行。
    C++优先队列类似队列,但是在这个数据结构中的元素按照一定的断言排列有序。

    • empty() 如果优先队列为空,则返回真。
    • pop() 删除第一个元素
    • push() 加入一个元素
    • size() 返回优先队列中拥有的元素的个数
    • top() 返回优先队列中有较高优先级的元素

    优先队列表示:
    priority_queue<int>que;//参数为数据类型,(默认优先级-最大值优先)构造队列
    如何控制优先级?
    有4种方法可以实现对优先级的控制:

    • 使用C++自带的库函数<functional>
    • 自定义优先级A
    • 自定义优先级B
    • 自定义优先级C

    (1)使用C++自带的库函数<functional>
    创建优先队列:

    priority_queue<int,vector<int>,less<int>>que1;//最大值优先
    priority_queue<int,vector<int>,greater<int>>que2;//最小值优先
    

    (2)自定义优先级A,队列元素为数值型

    struct cmp1{
    bool operator()(int &a,int &b){
    return a<b;}//最大值优先
    };
    
    struct cmp1{
    bool operator()(int &a,int &b){
    return a>b;}//最小值优先
    };
    

    创建优先队列:

    priority_queue<int,vector<int>,cmp1>que3;//最大值优先
    priority_queue<int,vector<int>,cmp2>que4;//最小值优先
    

    (3)自定义优先级B,队列元素为结构体型

    struct node1{
    int x,y;//结构体中的成员
    bool operator < (const node1 &a)const{
    return x<a.x;//最大值优先}
    }
    
    struct node2{
    int x,y;//结构体中的成员
    bool operator > (const node1 &a)const{
    return x>a.x;//最大值优先}
    }
    

    创建优先队列:

    priority_queue<node1>que3;//最大值优先
    priority_queue<node2>que4;//最小值优先
    

    (4)自定义优先级C,队列元素为结构体型

    struct node3{
    int x,y;//结构体中的成员
    }
    bool operator<(const node3 &a,const node3 &b)//在结构体外面定义
    {
    return a.x<b.x;//按成员x最大值优先
    }
    bool operator>(const node4 &a,const node4 &b)//在结构体外面定义
    {
    return a.x>b.x;//按成员x最大值优先
    }
    

    创建优先队列:

    priority_queue<node3>que7;//最大值优先
    priority_queue<node4>que8;//最小值优先
    
    展开全文
  • 该程序使用自适应辛普森规则计算 f(x) 从 x=a 到 x=b 的积分。 它通过简单地使用命令 int(@f,a,b) 来运行,其中 f 是使用函数文件(或过程)或作为匿名函数定义的。 定义函数时不使用 MATLAB 向量化。
  • finally使用规则

    2021-03-03 16:29:44
    Q :如果在catch里面有return语句,finally里面的代码还会执行吗?在return前执行还是return后执行? A:会执行,在return前执行 public class Demo { public static void main... private static int getNumber(int i

    Q :如果在catch里面有return语句,finally里面的代码还会执行吗?在return前执行还是return后执行?

    A:会执行,在return前执行

    public class Demo {
        public static void main(String[] args) {
            int i = getNumber(20);
           System.out.println(i); //10
        }
        private static int getNumber(int i) {
            System.out.println(i); //20
            try {
                i = 10;
                System.out.println(i / 0);
                i = 20;
                System.out.println(i);
            } catch (Exception e) {
                System.out.println(i);//10
                return i;  //在内存中其实已经形成返回10的操作,但是发现有finally,于是继续执行finally里面的代码
            } finally {
                i = 30;
                System.out.println(i);//30 执行完finally,又回去执行之前没有执行的返回 10的操作
            }
            return i;
        }
    }
    //20 10  30 10
    
    展开全文
  • //指针变量使用规则 int main(int argc,char*argv[]) { int a[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = a;//int *p=&a[0]两者等价 int i = 0; while (i<sizeof(a)/sizeof(a[0])) { printf("p[%d]=%d,&...
    #include<stdio.h>
    //指针变量使用规则
    int main(int argc,char*argv[])
    {
    	int a[10] = {1,2,3,4,5,6,7,8,9,10};
    	int *p = a;//int *p=&a[0]两者等价
    	int i = 0;
    	while (i<sizeof(a)/sizeof(a[0]))
    	{
    		printf("p[%d]=%d,&p[i]=0x%p",i,p[i],i,&p[i]);//使用指针下标进行表示
    		++i;
    	}
    	printf("******************");
    	while (i<sizeof(a) / sizeof(a[0]))
    	{
    		printf("p[%d]=%d,&p[i]=0x%p", i, *(p+i), i, p+i);//使用指针*进行表示 *(p+i)等价与p[i] p+i等价于&p[i]
    		++i;
    	}
    	printf("******************");
    	while (p-a<sizeof(a) / sizeof(a[0]))//指针偏移法,两个指针相减
    	{
    		printf("a[%d]=%d,p=0x%p", p-a, *p,p++);
    		++i;
    	}
    
    	while (*p)
    	{
    		printf("a[%d]=%d,p=0x%p", p - a, *p, p);
    		++i;
    	}
    	printf("******************");
    	do
    	{
    		printf("a[%d]=%d,p=0x%p", p - a, *p, p);
    	} while (*p++);
    	return 0;
    }

    2.指针变量做形式参数时候,经常用于改变主调函数实际参数(使用*或者下标来操作实参)

    #include<stdio.h>
    void Swap(int a, int b)//该函数并不能将两个整数进行交换,未改变了实惨
    {
    	int t = a;
    	a = b;
    	b = t;
    }
    
    void Swap1(int *a, int *b) ///该函数并不能将两个整数进行交换,未改变了实惨
    {
    	int* t = a;
    	a = b;
    	b = t;
    }
    
    void Swap1(int *a, int *b)//该函数并将两个整数进行了交换,改变了实惨
    {
    {
    	int t = *a;
    	*a = *b;
    	*b = t;
    }
    
    void Swap2(int &a, int &b)
    {
    	int t = a;
    	a = b;
    	b = t;
    }
    
    int main()
    {
    	int i = 10, j = 20;
    	Swap(i,j);
    	printf("i=%d,j=%d\n", i, j);
    	Swap1(&i,&j);
    	printf("i=%d,j=%d\n",i,j);
    	Swap2(i, j);
    	printf("i=%d,j=%d\n", i, j);
    	return 0;
    }

    3.查找字符串

    #include<stdio.h>
    void Reverse(char str[])
    {
    	char*p = str;
    	while (*p)
    		++p;
    	while (--p > str)
    	{
    		char t = *p;
    			*p = *str;
    			*str = t;
    		++str;
    	}
    	
    }
    
    int StringFind(char *str, char a)//查找字符串
    {
    	int i = 0;
    	while (*str)
    	{
    		if (*str == a)
    			return i;
    		++i;
    		++str;
    	}
    	printf("总共有%d个选中的字符%c",i,a);
    	return -1;
    }
    
    
    
    int main()
    {
    	char s[20];
    	scanf_s("%s",&s,sizeof(s));
    	puts(s);
    	Reverse(s);
    	puts(s);
    	StringFind(s,' ');
    	
    	return 0;
    }

     

    展开全文
  • MySQL 索引的使用规则

    2020-03-01 17:39:24
    文章目录索引的使用规则索引全值匹配最左前缀法则不在索引列上做任何操作存储引擎不能使用索引中范围条件右边的列使用覆盖索引使用不等于(!= 或者<>)时 索引失效like以通配符开头,索引失效字符串不加**单引号...
  • const使用规则

    2018-05-02 12:54:55
    例: const int ca =100; int const cb =100;这二者等价。意义相同。b. const用于封锁直接修饰的内容,将该内容变为只读。例如:int const *p1=&amp;a const直接修饰 *p1, 所以*p1不能作为左值存在...
  • 标准规则下禁止这样做,不过有三个实现方法。 1.结构体 struct array { int data[20]; }; struct array b = {{1,2,3}}; struct array a = b; 2.内存复制 #include&amp;lt;string.h&amp;gt; int a[20],b[20]...
  • C语言中默认规则:short int 即为int,long int 即为 long,前面若无unsigned符号默认signed型。 0和1每一个所占空间是一位(b),也是单片机存储器中最小的单位。 1B(字节)=8b(位) 二、C语言数据类型选择 (1)...
  • ASCII语法使用规则

    2020-07-17 15:44:37
    char zifu = 'A'; System.out.println((int)zifu); 单个字符数据类型是char 用(int)可以将char型转换成int整型输出
  • 为什么使用defer 在golang当中,defer代码块会在函数调用链表中增加一个函数调用。这个函数调用不是普通的函数调用,而是会在函数中正常返回,也就是在return之后添加一个函数调用。因此,defer通常用来释放函数内部...
  • 使用char或者varchar是不可取的,int类型更容易建立索引和进行检索,毕竟数字类型是数据库检索的基础,char类型的毕竟需要经过转换,而varchar就更复杂了,其排序不仅需要转换和计算,还需要访问和遵循数据库的排序...
  • void 指针的使用规则

    2019-11-25 20:28:51
    void 指针的使用规则 1、void 指针可以指向任意类型的数据 就是说可以用任意类型的指针对 void 指针赋值,如果要将 void 指针 p 赋给其他类型的指针,则需要强制类型转换,就本例而言:a=(int *)p。因为"无类型...
  • 使用规则const的引用对指针的引用总结auto:auto在编程时真正的用途1.代替冗长复杂的变量声明2.定义模板参数时,用于声明依赖模板参数的变量3.模板函数依赖于模板参数的返回值 现在我想做下面这样的运算: int i = 2...
  • CREATE TABLE mytable( ID INT NOT NULL, username VARCHAR(16) NOT NULL, INDEX myindex (username(16)) );
  • ip使用int存入数据库

    2013-08-07 13:52:36
    规则用“.”把ip分成4个数字 a1,a2,a3,a4 然后把 a1*256*256*256+a2*256*256+a3*256+a4存入数据库 //存入数据库  public long StrToFlo(string str)  {  char[] sp ={ '.' };  string[] a = str.Spl
  • roundingMode: 舍去规则(0 <= roundingMode <= 7) 分别有8个常量 ROUND_UP(0):第newScale位小数进1,后面舍去 BigDecimal b1 = new BigDecimal(3.1415926); BigDecimal b2 = b1.setS...
  • c++头文件使用规则

    2014-08-09 22:05:50
    1. 编译单元,一个.cc,或.cpp作为一个编译...extern int x; //变量是声明,并未实际分配地址,未产生实际目标代码  void print(); // 函数声明, 未产生实际目标代码  如int x; int x = 3 ; void print() {};
  • roundingMode: 舍去规则(0 <= roundingMode <= 7) 分别有8个常量 ROUND_UP(0):第newScale位小数进1,后面舍去 BigDecimal b1 = new BigDecimal(3.1415926); BigDecimal b2 = b1.setScale(2, ...
  • Java操作符使用规则

    2020-04-15 22:22:25
    |= 关于 |= 运算符:|= 运算符和 += 这一类的运算符一样,拆解开就是 a = a | b; 代码如下: public static strictfp ... int a = 5; // 0000 0101 int b = 3; // 0000 0011 a |= b; // 0000 00111 System.out...
  • 本文大致讲述了使用pgsql如何通过规则去创建分表的方法,写的不好还请多包涵。 1、先建一个主表 DROP TABLE if exists tb_passenger_hour; CREATE TABLE tb_passenger_hour( id int8 not null, group_id ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,367
精华内容 1,346
关键字:

int使用规则