精华内容
下载资源
问答
  • 类型安全
    千次阅读
    2016-03-24 18:32:44
    什么是类型安全?
    类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言,其根据在于该门编程语言是否提供保障类型安全的机制;有的时候也用“类型安全”形容某个程序,判别的标准在于该程序是否隐含类型错误。类型安全的编程语言与类型安全的程序之间,没有必然联系。好的程序员可以使用类型不那么安全的语言写出类型相当安全的程序,相反的,差一点儿的程序员可能使用类型相当安全的语言写出类型不太安全的程序。绝对类型安全的编程语言暂时还没有。
    C语言的类型安全
    C只在局部上下文中表现出类型安全,比如试图从一种结构体的指针转换成另一种结构体的指针时,编译器将会报告错误,除非使用显式类型转换。然而,C中相当多的操作是不安全的。以下是两个十分常见的例子:
    (1)printf格式输出

    /* - print.cpp
    * version:1.1
    */
    int main()
    {
    printf("%d\n",10);
    system("pause");
    return 0;
    }



    上面的代码很简单,printf函数中,%d与10匹配,结果正确。
    稍作修改:

    /* - print.cpp
    * version:1.2
    */
    int main()
    {
    printf("%f\n",10);
    system("pause");
    return 0;
    }



    %f浮点数与10并不匹配,但是编译通过,执行也没报错,但是结果却是:
    0.000000
    请按任意键继续. . .
    更进一步,把%f修改为%s,编译通过,执行将报错Access Violation。
    (2)malloc函数的返回值
    malloc是C中进行内存分配的函数,它的返回类型是void*即空类型指针,常常有这样的用法char* pStr=(char*)malloc(100*sizeof(char)),这里明显做了显式的类型转换。类型匹配尚且没有问题,但是一旦出现int* pInt=(int*)malloc(100*sizeof(char))就很可能带来一些问题,而这样的转换C并不会提示错误。
    C++的类型安全
    如果C++使用得当,它将远比C更有类型安全性。相比于C,C++提供了一些新的机制保障类型安全:
    (1)操作符new返回的指针类型严格与对象匹配,而不是void*;
    (2)C中很多以void*为参数的函数可以改写为C++模板函数,而模板是支持类型检查的;
    (3)引入const关键字代替#define constants,它是有类型、有作用域的,而#define constants只是简单的文本替换;
    (4)一些#define宏可被改写为inline函数,结合函数的重载,可在类型安全的前提下支持多种类型,当然改写为模板也能保证类型安全;
    (5)C++提供了dynamic_cast关键字,使得转换过程更加安全,因为dynamic_cast比static_cast涉及更多具体的类型检查。
    即便如此,C++也不是绝对类型安全的编程语言。如果使用不得当,同样无法保证类型安全。比如下面两个例子:

    int i=5;
    void* pInt=&i;
    double d=(*(double*)pInt);
    cout<

    输入结果不是5,而意想不到的结果:-9.25596e+061。又比如:

    #include<iostream>  
    using namespace std;  
    class Parent  
    {  
    };  
    class Child1:public Parent  
    {  
    public:  
        int i;  
        Child1(int e):i(e)  
        {  
        }  
    };  
    class Child2:public Parent  
    {  
    public:  
        double d;  
        Child2(double e):d(e)  
        {  
        }  
    };  
    int main()  
    {  
        Child1 c1(5);  
        Child2 c2(4.1);  
        Parent* pp;  
        Child1* pc1;  
       
        pp=&c1;  
        pc1=(Child1*)pp;  //#1 强制转换,由于类型仍然为Child1*,不造成错误  
        cout<<pc1->i<<endl;  
       
        pp=&c2;  
        pc1=(Child1*)pp;  //#2 强制转换,且类型发生变化,将造成错误  
        cout<<pc1->i<<endl;  
        system("pause");  
        return 0;  
    } 


    结果如下:
    5
    1717986918
    请按任意键继续. . .
    上面两个例子之所以引起类型不安全的问题,是因为程序员使用不得当。第一个例子用到了空类型指针void*,第二个例子则是在两个类型指针之间进行强制转换。因此,想保证程序的类型安全性,应尽量避免使用空类型指针void*,尽量不对两种类型指针做强制转换。
    更多相关内容
  • 【1】首先:C/C++不是类型安全的语言。类型安全是指同一段内存在不同的地方,会被强制要求使用相同的办法来解释(内存中的数据是用类型来解释的)。 //类型安全性意味着编译器将在编译时验证类型,如果尝试将错误的类型...

    【1】首先:C/C++不是类型安全的语言。
    类型安全是指同一段内存在不同的地方,会被强制要求使用相同的办法来解释(内存中的数据是用类型来解释的)。
    //类型安全性意味着编译器将在编译时验证类型,如果尝试将错误的类型分配给变量,则抛出错误。
    Java语言是类型安全的,除非强制类型转换。
    C语言不是类型安全的,因为同一段内存可以用不同的数据类型来解释,比如1用int来解释就是1,用boolean来解释就是true。

    ------------------------------------------------

    什么是类型安全?
           类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言,其根据在于该门编程语言是否提供保障类型安全的机制;有的时候也用“类型安全”形容某个程序,判别的标准在于该程序是否隐含类型错误。类型安全的编程语言与类型安全的程序之间,没有必然联系。绝对类型安全的编程语言暂时还没有。

    C语言的类型安全:
           C只在局部上下文中表现出类型安全,比如试图从一种结构体的指针转换成另一种结构体的指针时,编译器将会报告错误,除非使用显式类型转换。然而,C中相当多的操作是不安全的。以下是两个十分常见的例子:

    <1>printf格式输出

    int main()
    {
        printf("%d\n",10);
        system("pause");
        return 0;
    }

      上面的代码很简单,printf函数中,%d与10匹配,结果正确。但如果稍作修改:

    int main()
    {
        printf("%f\n",10);
        system("pause");
        return 0;
    }
    

    %f浮点数与10并不匹配,但是编译通过,执行也没报错,但是结果却是:
    0.000000
    更进一步,把%f修改为%s,编译通过,执行将报错Access Violation。

    <2>malloc函数的返回值
              malloc是C中进行内存分配的函数,它的返回类型是void*即空类型指针,常常有这样的用法char* pStr=(char*)malloc(100*sizeof(char)),这里明显做了显式的类型转换。类型匹配尚且没有问题,但是一旦出现int* pInt=(int*)malloc(100*sizeof(char))就很可能带来一些问题,而这样的转换C并不会提示错误。

    C++的类型安全:
    如果C++使用得当,它将远比C更有类型安全性。相比于C,C++提供了一些新的机制保障类型安全:
    (1)操作符new返回的指针类型严格与对象匹配,而不是void*;
    (2)C中很多以void*为参数的函数可以改写为C++模板函数,而模板是支持类型检查的;
    (3)引入const关键字代替#define constants,它是有类型、有作用域的,而#define constants只是简单的文本替换;
    (4)一些#define宏可被改写为inline函数,结合函数的重载,可在类型安全的前提下支持多种类型,当然改写为模板也能保证类型安全;
    (5)C++提供了dynamic_cast关键字,使得转换过程更加安全,因为dynamic_cast比static_cast涉及更多具体的类型检查。

      即便如此,C++也不是绝对类型安全的编程语言。如果使用不得当,同样无法保证类型安全。比如下面两个例子:

    int i=5;
    void* pInt=&i;
    double d=(*(double*)pInt);
    cout<<d<<endl;

    输入结果不是5,而意想不到的结果:-9.25596e+061。又比如:

    #include<iostream>
    using namespace std;
    class Parent
    {
    };
    class Child1:public Parent
    {
    public:
        int i;
        Child1(int e):i(e)
        {
        }
    };
    class Child2:public Parent
    {
    public:
        double d;
        Child2(double e):d(e)
        {
        }
    };
    int main()
    {
        Child1 c1(5);
        Child2 c2(4.1);
        Parent* pp;
        Child1* pc1;
     
        pp=&c1;
        pc1=(Child1*)pp;  //#1 强制转换,由于类型仍然为Child1*,不造成错误
        cout<<pc1->i<<endl;
     
        pp=&c2;
        pc1=(Child1*)pp;  //#2 强制转换,且类型发生变化,将造成错误
        cout<<pc1->i<<endl;
        system("pause");
        return 0;
    }

           上面两个例子之所以引起类型不安全的问题,是因为程序员使用不得当。第一个例子用到了空类型指针void*,第二个例子则是在两个类型指针之间进行强制转换。因此,想保证程序的类型安全性,应尽量避免使用空类型指针void*,尽量不对两种类型指针做强制转换
     

    展开全文
  • 什么是类型安全类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言,其根据在于该门编程语言是否提供保障类型安全的机制;有的时候也...

    什么是类型安全?
    类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言,其根据在于该门编程语言是否提供保障类型安全的机制;有的时候也用“类型安全”形容某个程序,判别的标准在于该程序是否隐含类型错误。类型安全的编程语言与类型安全的程序之间,没有必然联系。好的程序员可以使用类型不那么安全的语言写出类型相当安全的程序,相反的,差一点儿的程序员可能使用类型相当安全的语言写出类型不太安全的程序。绝对类型安全的编程语言暂时还没有。
    C语言的类型安全
    C只在局部上下文中表现出类型安全,比如试图从一种结构体的指针转换成另一种结构体的指针时,编译器将会报告错误,除非使用显式类型转换。然而,C中相当多的操作是不安全的。以下是两个十分常见的例子:
    (1)printf格式输出

    /* - print.cpp
    * version:1.1
    */
    int main()
    {
    printf("%d\n",10);
    system("pause");
    return 0;
    }
    

    上面的代码很简单,printf函数中,%d与10匹配,结果正确。
    稍作修改:
     

    /* - print.cpp
    * version:1.2
    */
    int main()
    {
    printf("%f\n",10);
    system("pause");
    return 0;
    }
    

    %f浮点数与10并不匹配,但是编译通过,执行也没报错,但是结果却是:
    0.000000
    请按任意键继续. . .
    更进一步,把%f修改为%s,编译通过,执行将报错Access Violation。
    (2)malloc函数的返回值
    malloc是C中进行内存分配的函数,它的返回类型是void*即空类型指针,常常有这样的用法char* pStr=(char*)malloc(100*sizeof(char)),这里明显做了显式的类型转换。类型匹配尚且没有问题,但是一旦出现int* pInt=(int*)malloc(100*sizeof(char))就很可能带来一些问题,而这样的转换C并不会提示错误。
    C++的类型安全
    如果C++使用得当,它将远比C更有类型安全性。相比于C,C++提供了一些新的机制保障类型安全:
    (1)操作符new返回的指针类型严格与对象匹配,而不是void*;
    (2)C中很多以void*为参数的函数可以改写为C++模板函数,而模板是支持类型检查的;
    (3)引入const关键字代替#define constants,它是有类型、有作用域的,而#define constants只是简单的文本替换;
    (4)一些#define宏可被改写为inline函数,结合函数的重载,可在类型安全的前提下支持多种类型,当然改写为模板也能保证类型安全;
    (5)C++提供了dynamic_cast关键字,使得转换过程更加安全,因为dynamic_cast比static_cast涉及更多具体的类型检查。
    即便如此,C++也不是绝对类型安全的编程语言。如果使用不得当,同样无法保证类型安全。比如下面两个例子:

    例1:

    #include <iostream>
    using namespace std;
    
    int main()
    {
    	int i = 5;
    	void* pInt = &i;
    	double d = (*(double*)pInt);
    	cout << d << endl;
    
    	return 0;
    }
    

    VS2015输出:

    结果不是5!

    例2:

    #include<iostream>  
    using namespace std;
    class Parent
    {
    };
    class Child1 :public Parent
    {
    public:
    	int i;
    	Child1(int e) :i(e)
    	{
    	}
    };
    class Child2 :public Parent
    {
    public:
    	double d;
    	Child2(double e) :d(e)
    	{
    	}
    };
    int main()
    {
    	Child1 c1(5);
    	Child2 c2(4.1);
    	Parent* pp;
    	Child1* pc1;
    
    	pp = &c1;
    	pc1 = (Child1*)pp;  //#1 强制转换,由于类型仍然为Child1*,不造成错误  
    	cout << pc1->i << endl;
    
    	pp = &c2;
    	pc1 = (Child1*)pp;  //#2 强制转换,且类型发生变化,将造成错误  
    	cout << pc1->i << endl;
    
    	return 0;
    }

    输出:

    上面两个例子之所以引起类型不安全的问题,是因为程序员使用不得当。第一个例子用到了空类型指针void*,第二个例子则是在两个类型指针之间进行强制转换。因此,想保证程序的类型安全性,应尽量避免使用空类型指针void*,尽量不对两种类型指针做强制转换。

    总结:

    类型安全是指同一段内存在不同的地方,会被强制要求使用相同的办法来解释(内存中的数据是用类型来解释的)。

    Java语言是类型安全的,除非强制类型转换。

    C语言不是类型安全的,因为同一段内存可以用不同的数据类型来解释,比如1用int来解释就是1,用boolean来解释就是true。

     

    原文链接:https://blog.csdn.net/chengonghao/article/details/50974022

    展开全文
  • c++之类型安全

    千次阅读 2017-06-30 22:47:37
    类型安全简单来说就是访问可以被授权访问的内存位置,类型安全的代码不会试图访问自己未被授权的内存区域。

    1、什么是类型安全

    类型安全简单来说就是访问可以被授权访问的内存位置,类型安全的代码不会试图访问自己未被授权的内存区域。一方面,类型安全被用来形容编程语言,主要根据这门编程语言是否提供类型安全的保障机制;另一方面,类型安全也可以用来形容程序,根据这个程序是否隐含类型错误。类型安全的语言和程序之前,其实没有必然的联系。类型安全的语言,使用不当,也可能写出来类型不安全的程序;类型不安全的语言,使用得当,也可以写出非常安全的程序。


    2、C的类型安全

    C语言不是类型安全的语言,原因如下:

    1)很多情况下,会存在类型隐式转换,比如bool自动转成int类型;

    2)malloc函数返回的是void *的空类型指针,通常需要这样的显示类型转换char* pStr=(char*)malloc(100*sizeof(char)),类型匹配没有问题。但如果出现int* pInt=(int*)malloc(100*sizeof(char))这样的转换,可能会带来一些问题,但C并不会提示。

    当然,在有些情况下表现还是类型安全的,当从一个结构体指针转换成另一个结构体指针时,编译器会报错,除非显式转换。


    3、C++的类型安全

    C++也不是类型安全的语言,但远比C更具类型安全。相比于C,提供了一些安全保障机制:

    1)用操作符new来申请内存,严格与对象类型匹配,而malloc是void *;

    2)函数参数为void *的可以改写成模板,模板支持运行时检查参数类型;

    3)使用const代替define来定义常量,具有类型、作用域,而不是简单的文本替换;

    4)使用inline代替define来定义函数,结合函数的重载,在类型安全的前提下可以支持多种类型,如果改写成模板,会更安全;

    5)提供dynamic_cast使得转换过程更安全。

    尽管如此,但如果使用空类型指针或者在两个不同类型指针间做强制转换,很可能引发类型不安全的问题。


    4、总结

    想要保证程序的类型安全,尽量避免使用空类型指针,尽量不对不同类型的指针做强制转换。



    展开全文
  • (1)类型安全 类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言,其根据在于该门编程语言是否提供保障类型安全的机制;有的时候也用...
  • SpringBoot中类型安全的属性注入

    千次阅读 2020-02-10 19:34:06
    一、什么叫类型安全的属性注入 在此之前,需要了解一下什么叫属性注入,可以参考我的上一篇博客,讲的就是属性注入,参考链接如下: Spring属性注入 二、为什么需要类型安全 首先,我们需要考虑如下两个问题: 1.若...
  • C++不是类型安全的语言

    千次阅读 2016-07-20 21:34:56
    在C++语言中,下列说法正确的是: 正确答案: D 你的答案: 空 (错误) ...inline函数表示编译器一定会将函数体直接插入到调用此函数的地方,这样可以加快...C++不是类型安全的语言 添加笔记 收藏 纠错
  • 【C/C++】什么是类型安全

    千次阅读 2016-10-04 10:25:19
    什么是类型安全 转自:http://hi.baidu.com/chenfalei/blog/item/f33ac0133500ac21dd540186.html 编程语言的最终梦想:静态类型安全 常听人说“强类型”。但个人对强类型都有不同的理解。 有的认为C++...
  • C语言原来有简单的语法实现强制类型转换,为什么C++还要确定新特性实现强制类型转换呢?...2,将多态基类指针转换成派生类指针时不检查安全性,即无法判断转换后的指针是否确实指向一个派生类对象。 3
  • 谈谈C++类型安全

    万次阅读 2011-08-16 23:15:08
    什么是类型安全类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言,其根据在于该门编程语言是否提供保障类型安全的机制;有的时候也...
  • Medium等级 第一步:先关闭代理 第二步:选择Medium的安全等级 第三步:打开代理,输入错误的用户名和密码,将报文发送给暴力破解器 第四步:暴力破解 Sniper(狙击手)类型 选择 Sniper Battering ram(撞击物)...
  • 这个jdk5.0引入的泛型. 在eclipse中你只要在声明集合的时候写成这样ArrayList list...你这样定义以后,这个list里面add就只能添加String类型,如果你添加int或者别的引用类型,编译器就会报错。 完全可以忽略掉这个警告
  • Java语言的类型安全

    千次阅读 2011-12-28 11:43:08
    Java是强类型语言,也就是说,编译器会对代码进行检查,确保变量的每一次赋值,方法的每一次调用都是符合类型的。如果有任何不想符合的情况,Java编译器就会给出错误。 Java的类型检查是基于这样一个简单的事实:每...
  • 首先,java语言室类型安全的,通常我们遇到这个问题是出现在Object转化为目标类型时, 这个转化并不是安全的。这个问题普遍认为因为 使用了jdk1.5或者1.6的泛型, request.getAttribute("***")得到的是一个...
  • C++的四种安全类型转换方式

    千次阅读 2019-09-01 09:56:09
    第三种: 如图第一张图所示,类似于c的强转
  • 然而有的时候我们需要更多的灵活性,如数据库可以用任意多的Column,如果能以类型安全的方式访问所有Columns就好了,幸运的是 有一种方法可以很容易的做到这一点,就是将key进行参数化,见以下代码 1 public ...
  • 文章目录简介Non-nullable类型Nullable List Of Strings 和 List Of Nullable Strings!操作符late关键字总结 简介 在Dart 2.12中引入了null safety的新特性,也就是说dart程序中默认类型都是非空的,除非你显示告诉...
  • list的线程安全类型

    千次阅读 2016-09-17 23:58:22
    list安全可以用Vector代替,或者用Collections.synchronizedList(new ArrayList())来定义一个线程安全的list。
  • 浅谈PHP弱类型安全

    万次阅读 2015-01-14 11:54:07
    0x00 弱类型初探 没有人质疑php的简单强大,它提供了很多特性供开发者使用,其中一个就是弱类型机制。 在弱类型机制下 你能够执行这样的操作 1 2 3 4 5 $var = 1; $var = array(); $var = "string"; ?...
  • 引用类型导致的线程安全问题

    千次阅读 2021-12-25 22:17:06
    多线程操作共享变量,共享变量为引用类型,出现引用类型值出现改变的问题。 二、基本数据类型和引用数据类型在内存中的对比 对比 基本数据类型 引用数据类型 存储地址 在栈中进行分配 ...
  • 安全测试主要类型

    千次阅读 2016-01-26 08:58:15
    本篇博文主要介绍安全测试的主要类型,及其最基本的概念,不涉及到每一安全类型的详细内容,每一类型的详细内容将在后续的博文中分开详细讲解。 安全测试类型表格 如下: 类型 简单描述 失效的身份验证机制 只对...
  • Predicate condition = criteriaBuilder.gt(employee.get(Employee_.age), 24); criteriaQuery.where(condition);
  • 安全上下文的认识

    千次阅读 2018-05-16 23:04:51
    一、临时修改安全上下文在/mnt下建立一个文件,并将它移动到ftp目录下,在我们登陆时lftp时,没有westos文件在/var/ftp下建立一个文件
  • 无线网络(Wireless Network)发展至今已经出现了多种安全认证方式。支持新的认证方式的无线设备一般可以兼容旧的安全认证方式,然而旧的设备往往并没有那么快被淘汰,有时候会因为没有考虑到兼容问题而导致某些设备...
  • SQL的常用数据类型

    千次阅读 2017-06-24 10:59:17
    几个常用的数据类型的总结。做个笔记ヽ(ー_ー)ノ
  • 编辑网站根目录下的wp-config.php文件 增加一行代码 define( 'ALLOW_UNFILTERED_UPLOADS', true); 保存即可 出于安全考虑,网站维护完毕后,建议将这行代码删除
  • 【WiFi】WiFi安全类型

    千次阅读 2019-05-14 14:36:59
    WPA-PSK/WPA2-PSK安全类型其实是WPA/WPA2的一种简化版别,它是依据同享密钥的WPA形式,安全性很高,设置也对比简单,合适普通家庭用户和小型企业运用。 WPA-PSK(TKIP),个人模式,加密方式为TKIP(11N形式不支持...
  • 枚举类型为什么是线程安全的? 我们定义的一个枚举,在第一次被真正用到的时候,会被虚拟机加载并初始化,而这个初始化过程是线程安全的。而我们知道,解决单例的并发问题,主要解决的就是初始化过程中的线程安全...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,840,938
精华内容 736,375
关键字:

类型安全

友情链接: 65586201.rar