精华内容
下载资源
问答
  • 参考:http://blog.sina.com.cn/s/blog_74f32c400101a1ah.html 参考文档:OpenCV中Mat详解 ...经过查阅浏览大神解释博客,个人理解如下: 1、cvLoadImage()与imread()等函数区别深入了解

    参考:http://blog.sina.com.cn/s/blog_74f32c400101a1ah.html

    参考文档:OpenCV中Mat的详解


    之前一直再用IplImage类型,昨天接触Mat,使用起来发现有些不一样,函数与之前的IplImage的有一点点不一样

    经过查阅和浏览大神的解释和博客,个人理解如下:

    1、cvLoadImage()与imread()等函数区别深入了解:

    参考:http://blog.sina.com.cn/s/blog_74f32c400101a1ah.html

    c++有命名空间这一解释,using namespace  ;

    using namespace cv;的具体意思是:

    例如Cvrect和Rect以及cvresize和resize都是表示同一个东西,前者都是指cvrect,后者都是指cvresize,如果在程序开始写上 using namespace cv;则cvrect可以简写为rect,cvresize可以简写为resize,如果没有写上的using namespace cv;那就用cv......所有的以新风格命名的函数都在 cv 命名空间中,如果希望不要每次都输入 cv:: ,则可使用下面语句:using namespace cv;

    2、IplImage和Mat区别

    产生不同的原因:IplImage使用的是C结构,而Mat使用的是C++结构

    使用IplImage时需要手动管理内存,例如使用cvCreateImage(),cvReleaseImage()等函数创建和释放内存,而且使用不熟练的时候我们会发现IplImage经常出现内存异常,当使用熟练时,程序规模较小时,IplImage这是没有问题的,可是一旦代码变得越来越大他就会越来越来挣扎着处理这一切而不是着眼于实际解决自己的开发目标。

    Mat使用的是c++结构,c++中类的概念,在opencv2.0以上,引入例如C++接口,类的使用,使得代码变得更加简洁(c++中类使用. ,c中结构使用->)。

    关于使用Mat的第一件事是:不再需要手动分配其内存大小,当不需要使用它的时候也不再需要手动释放它,例如如下程序的区别:

    IplImage程序:

    #include "cv.h"
    #include "cxcore.h"
    #include "highgui.h"
    #include "stdio.h"


    int main(void)
    {
    IplImage* Image;
    IplImage* Image_Gray; // c语言中,声明需要在语句之前
    Image = cvLoadImage("D:\\opencv2.4.4\\lema.jpg", 1); // 载入图片,1-彩色
    Image_Gray = cvCreateImage(cvGetSize(Image), Image->depth, 1); // 创建内存
    cvCvtColor(Image, Image_Gray, CV_BGR2GRAY); // 彩色图->灰度图
    cvShowImage("Image", Image);
    cvShowImage("Image_Gray", Image_Gray);
    cvWaitKey(0);
    cvReleaseImage(&Image);
    cvReleaseImage(&Image_Gray);
    return 0;
    }

    Mat程序:

    #include "cv.h"
    #include "cxcore.h"
    #include "highgui.h"
    #include <iostream>
    using namespace std;
    using namespace cv;


    int main(void)
    {
    Mat Image = imread("D:\\opencv2.4.4\\lema.jpg",1);
    imshow("Image", Image);
    Mat Image_Gray;
    cvtColor(Image, Image_Gray, CV_BGR2GRAY, 0);
    imshow("Image_Gray", Image_Gray);
    waitKey(0);
    return 0;
    }

    Mat本质是由两个数据部分组成的类:矩阵头(包含信息有矩阵的大小、用于存储的方法、矩阵存储的地址等),一个指针(指向了像素值的矩阵,可根据选择用于存储的方法采用任何维度存储数据)。矩阵头部的大小是恒定的,然而,矩阵本身的大小因图像的不同而不同,通常是较大的数量级。因而,当你的程序中传递图像并在有些时候需要创建图像副本时,需要花费很大的代价生成图像矩阵本身,而不是图像的头部。

    opencv是图像处理库,它包含大量的图像处理函数,因此,图像传给库中的函数是一种常见的做法。为提高大程序的速度,opencv使用引用计数系统,其思想是Mat的每个对象都具有自己的头,让矩阵指针指向同一地址的实例之间共享该矩阵。此外,拷贝运算符将智能复制矩阵头部,也将复制指向矩阵的指针,但不复制矩阵本身。

    (时间原因,这次先码这些字...下次继续(二))

    展开全文
  • 在今天上课时候,听老师讲时候举得“餐厅”例子感觉很形象,所以想利用这个例子,简单说一下并记录自己这个想法,以便交流以后复习使用。 Factory Method Pattern (工厂方法模式) 说到...

    软件构造 Blog-6


    写在最前面

    在6.2 Design Patterns for Maintainability中提到了三个不同的构建模式,在第一次看的时候感觉不好理解。在今天上课的时候,听老师讲的时候举得“餐厅”的例子感觉很形象,所以想利用这个例子,简单的说一下并记录自己的这个想法,以便交流和以后复习使用。

    Factory Method Pattern (工厂方法模式)

    说到工厂方法,其实本质就是尽量避免Client使用SomeObject object = new SomeObject()这种可以直接使用new构建对象的方法。转而提供一些工厂类来避免暴露我的具体的类名。举个例子来说明,有一家餐馆,卖各种调料酱,这家店的老板告诉他的顾客,这些调料酱有沙拉酱,烧烤酱和番茄酱等等,但怎么要看顾客的使用就行;还有一家餐馆,老板不想让顾客知道我用的什么酱,我只告诉你你可以用调料酱。
    上面两个例子,前面那个餐馆就可以视为没有工厂,直接用new来“使用酱”;后边的餐馆,就有一个工厂屏蔽了顾客和餐馆,只有餐馆的人知道我给你的啥酱。

    Abstract Factory(抽象工厂模式)

    抽象工厂模式:提供接口以创建一组相关/相互依赖的对象,但不需要指明其具体类。

    还是餐馆的例子,还有一家老板,比较死板,我不想让你顾客因为你要的酱不对影响我菜的味道,我规定你要了其中某种菜,只能再要与其搭配的那种酱,而不能要其他的酱。比如,我要了沙拉,想要酱那么我只提供沙拉酱;但是你有自由选择不要酱(即我利用Abstract Factory创建的不是一个完整的产品,而是一个产品族)。

    Builder (构造器模式)

    创建复杂队形,包含多个组成部分

    仍然是餐馆的例子,还有一家老板,死板但是良心,我觉得你要了我的菜只有搭配我的酱才会更好吃,所以我干脆你只要点了我的菜就认为你需要我的酱。比如,我要了薯条套餐,直接给我的就是薯条和番茄酱(Builder模式创建的是一个完整的产品,有多个部分组成,Client不需要知道我各个部分是怎样创建怎样组合的)。

    最后

    这仅仅是我个人的一些理解,可能有有所偏差,如果有误希望大家能够私信或者评论我。

    展开全文
  • 关于springMVC中使用session的理解

    万次阅读 2016-08-12 19:57:47
    【参考】...【参考】理解springMVC中ModelSession属性 http://blog.csdn.net/maoyeqiu/article/details/49719437 ------------------------------------------------
    
     

    【参考】http://www.cnblogs.com/waytofall/p/3460533.html

    【参考】理解springMVC中的Model和Session属性http://blog.csdn.net/maoyeqiu/article/details/49719437

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

    【转载】http://fengzhiyin.iteye.com/blog/1323240

    本文部分内容参考至:http://anffvf.blog.163.com/blog/static/314754201101342148699/

     

    WEB 应用通常会引入 Session,用来在服务端和客户端之间保存一系列动作/消息的状态,比如网上购物维护 user 登录信息直到 user 退出。在 user 登录后,Session 周期里有很多 action 都需要从 Session 中得到 user,再验证身份权限,或者进行其他的操作。这其中就会涉及到程序去访问 Session属性的问题。在java中,Servlet 规范提供了 HttpSession对象来满足这种需求。开发人员可以从 HttpServletRquest对象得到 HttpSession,再从HttpSession中得到状态信息。

    还是回到购物车的例子,假设在 controller 某个方法(本文简称为action)中我们要从HttpSession中取到user对象。如果基于Servlet,标准的代码会是这样的:

    Java代码 复制代码 收藏代码
    1. public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {  
    2. User user = (User)req.getSession().getAttribute("currentUser");  
    3. //  
    4. }  
    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    User user = (User)req.getSession().getAttribute("currentUser");
    //
    }

    这样的代码在传统的Servlet程序中是很常见的:因为使用了 Servlet API,从而对 Servlet API产生依赖。这样如果我们要测试 action,我们就必须针对 HttpServletRequest、HttpServletResponse 和 HttpSession类提供 mock 或者 stub 实现。当然现在已经有很多开源的 Servlet 测试框架帮助我们减轻这个痛苦,包括 Spring 就自带了对了这些类的 stub 实现,但那还是太冗繁琐碎了。那有没有比较好的办法来让我们的 controller 更 POJO,让我们的 action 脱离 Servlet API 依赖,更有益于测试和复用呢?我们来看看在 Spring2.5 中访问 Session 属性的几种策略,并将在本博的后续文章继续探究解决方案选择后面的深层含义。

    (一)通过方法参数传入HttpServletRequest对象或者HttpSession对象

    Spring对annotationed的 action 的参数提供自动绑定支持的参数类型包括 Servlet API 里面的 Request/Response/HttpSession(包含Request、Response在Servlet API 中声明的具体子类)。于是开发人员可以通过在 action 参数中声明 Request 对象或者 HttpSession 对象,来让容器注入相应的对象。

    action 的代码如下:

    Java代码 复制代码 收藏代码
    1. @RequestMapping  
    2. public void hello(HttpSession session){  
    3. User user = (User)session.getAttribute("currentUser");  
    4. //  
    5. }  
    @RequestMapping
    public void hello(HttpSession session){
    User user = (User)session.getAttribute("currentUser");
    //
    }

    优点:

    1. 程序中直接得到底层的 Request/HttpSession 对象,直接使用 Servlet API 规范中定义的方法操作这些对象中的属性,直接而简单。
    2. action 需要访问哪些具体的 Session 属性,是由自己控制的,真正精确到 Session 中的每个特定属性。

    不足:

    1. 程序对 Servlet API 产生依赖。虽然 controller 类已经不需要从 HttpServlet 继承,但仍需要 Servlet API 才能完成编译运行,乃至测试。
    2. 暴露了底层 Servlet API,暴露了很多并不需要的底层方法和类,开发人员容易滥用这些 API。

    (二)通过定制拦截器(Interceptor)在controller类级别注入需要的User对象

    Interceptor 是 Spring 提供的扩展点之一,SpringMVC 会在 handle 某个 request 前后调用在配置中定义的 Interceptor 完成一些切面的工作,比如验证用户权限、处理分发等,类似于 AOP。那么,我们可以提取这样一个“横切点”,在 SpringMVC 调用 action 前,在 Interceptor 的 preHandle 方法中给 controller 注入 User 成员变量,使之具有当前登录的 User 对象。

    此外还需要给这些特定 controller 声明一类 interface,比如 IUserAware。这样开发人员就可以只针对这些需要注入 User 对象的 controller 进行注入增强。

    IUserAware 的代码:

    Java代码 复制代码 收藏代码
    1. public interface IUserAware {  
    2. public void setUser();  
    3. }  
    public interface IUserAware {
    public void setUser();
    }
    

     
    controller 的代码:

    Java代码 复制代码 收藏代码
    1. @Controller  
    2. public GreetingController implements IUserAware {  
    3. private User user;  
    4. public void setUser(User user){  
    5. this.user = user;  
    6. }  
    7.   
    8. @RequestMapping  
    9. public void hello(){  
    10. //user.sayHello();  
    11. }  
    12. //  
    13. }  
    @Controller
    public GreetingController implements IUserAware {
    private User user;
    public void setUser(User user){
    this.user = user;
    }
    
    @RequestMapping
    public void hello(){
    //user.sayHello();
    }
    //
    }

     

    Interceptor 的代码:

    Java代码 复制代码 收藏代码
    1. public class UserInjectInterceptor extends HandlerInterceptorAdapter {  
    2. @Override  
    3. public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {  
    4. if (handler.isAssignableFrom(IUserAware)){  
    5. User user = (User)httpServletRequest.getSession().getAttribute("currentUser");  
    6. IUserAware userAware = (IUserAware) handler;  
    7. userAware.setUser(user);  
    8. }  
    9. return super.preHandle(httpServletRequest, httpServletResponse, handler);  
    10. }  
    11. //  
    12. }  
    public class UserInjectInterceptor extends HandlerInterceptorAdapter {
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
    if (handler.isAssignableFrom(IUserAware)){
    User user = (User)httpServletRequest.getSession().getAttribute("currentUser");
    IUserAware userAware = (IUserAware) handler;
    userAware.setUser(user);
    }
    return super.preHandle(httpServletRequest, httpServletResponse, handler);
    }
    //
    }

     

    为了让 SpringMVC 能调用我们定义的 Interceptor,我们还需要在 SpringMVC 配置文件中声明该 Interceptor,比如:

    Xml代码 复制代码 收藏代码
    1. <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">  
    2. <property name="interceptors">  
    3. <list>  
    4. <ref bean="userInjectInterceptor"/><!-- userInjectInterceptor bean 的声明省略-->  
    5. </list>  
    6. </property>  
    7. </bean>  

     

    优点:

    1. 对 Servlet API 的访问被移到了自 SpringMVC API 扩展的 Interceptor,controller 不需要关心 User 如何得到。
    2. 开发人员可以通过随时添加或移除 Interceptor 来完成对不同参数在某一类型 controller 上的注入。
    3. controller 的 User 对象通过外界注入,测试时开发人员可以很容易地注入自己想要的 User 对象。
    4. controller 类去掉了对 Servlet API 的依赖,更 POJO 和通用。
    5. controller 类是通过对 interface 的声明来辅助完成注入的,并不存在任何继承依赖

    不足:

    1. SpringMVC 对 controller 默认是按照单例(singleton)处理的,在 controller 类中添加一个成员变量,可能会引起多线程的安全问题。
    2. 因为 User 对象是定义为 controller 的成员变量,而且是通过 setter 注入进来,在测试时需要很小心地保证对controller 注入了 User 对象,否则有可能我们拿到的就不一定是一个“好公民”(Good Citizen)。


    其实,一言而蔽之,这些不足之所以出现,是因为我们把某个 action 级别需要的 User 对象上提到 controller 级别,破坏了 the convention of stateless for controller classes,而 setter 方式的注入又带来了一些隐含的繁琐和不足。当然,我们可以通过把 controller 声明为“prototype”来绕过 stateless 的约定,也可以保证每次 new 一个 controller 的同时给其注入一个 User 对象。但是我们有没有更简单更 OO 的方式来实现呢?答案是有的。

    (三)通过方法参数处理类(MethodArgumentResolver)在方法级别注入User对象

    正如前面所看到的,SpringMVC 提供了不少扩展点给开发人员扩展,让开发人员可以按需索取,plugin 上自定义的类或 handler。那么,在 controller 类的层次上,SpringMVC 提供了 Interceptor 扩展,在 action 上有没有提供相应的 handler 呢?如果我们能够对 action 实现注入,出现的种种不足了。

    通过查阅 SpringMVC API 文档,SpringMVC 其实也为 action 级别提供了方法参数注入的 Resolver 扩展,允许开发人员给 HandlerMapper 类 set 自定义的 MethodArgumentResolver。

    action 的代码如下:

    Java代码 复制代码 收藏代码
    1. @RequestMapping  
    2. public void hello(User user){  
    3. //user.sayHello()  
    4. }  
    @RequestMapping
    public void hello(User user){
    //user.sayHello()
    }

     

    Resolver 的代码如下:

    Java代码 复制代码 收藏代码
    1. public class UserArgumentResolver implements WebArgumentResolver {  
    2.   
    3. public Object resolveArgument(MethodParameter methodParameter, NativeWebRequest webRequest) throws Exception {  
    4. if (methodParameter.getParameterType().equals(User.class)) {  
    5. return webRequest.getAttribute("currentUser", RequestAttributes.SCOPE_SESSION);  
    6. }  
    7. return UNRESOLVED;  
    8. }  
    9. }  
    public class UserArgumentResolver implements WebArgumentResolver {
    
    public Object resolveArgument(MethodParameter methodParameter, NativeWebRequest webRequest) throws Exception {
    if (methodParameter.getParameterType().equals(User.class)) {
    return webRequest.getAttribute("currentUser", RequestAttributes.SCOPE_SESSION);
    }
    return UNRESOLVED;
    }
    }

     
    配置文件的相关配置如下:

    Xml代码 复制代码 收藏代码
    1. <bean class="org.springframework.web.servlet.mvc.annotation.OwnAnnotationMethodHandlerAdapter">  
    2. <property name="customArgumentResolver">  
    3. <ref bean="userArgumentResolver"/><!-- userArgumentResolver bean 的定义省略 -->  
    4. </property>  
    5. </bean>  

     

    优点:

    1. 具备第二种方案的所有优点

    2. 真正做到了按需分配,只在真正需要对象的位置注入具体的对象,减少其他地方对该对象的依赖。
    3. 其他人能很容易地从 action 的参数列表得知 action 所需要的依赖,API 更清晰易懂。
    4. 对于很多 action 需要的某一类参数,可以在唯一的设置点用很方便一致的方式进行注入。

    不足:

    1. 对象依赖注入是针对所有 action, 注入粒度还是较粗。不能做到具体 action 访问具体的 Session 属性

    (四)通过 SpringMVC 的 SessionAttributes Annotation 关联 User 属性

    SpringMVC 文档提到了 @SessionAttributes annotation,和 @ModelAttribute 配合使用可以往 Session 中存或者从 Session 中取指定属性名的具体对象。文档里说;

    The type-level @SessionAttributes annotation declares session attributes used by a specific handler. This will typically list the names of model attributes which should be transparently stored in the session or some conversational storage, serving as form-backing beans between subsequent requests.

    很明显,@SessionAttributes 是用来在 controller 内部共享 model 属性的。从文档自带的例子来看,标注成 @SessionAttributes 属性的对象,会一直保留在 Session 或者其他会话存储中,直到 SessionStatus 被显式 setComplete()。那这个 annotation 对我们有什么帮助呢?

    答案就是我们可以在需要访问 Session 属性的 controller 上加上 @SessionAttributes,然后在 action 需要的 User 参数上加上 @ModelAttribute,并保证两者的属性名称一致。SpringMVC 就会自动将 @SessionAttributes 定义的属性注入到 ModelMap 对象,在 setup action 的参数列表时,去 ModelMap 中取到这样的对象,再添加到参数列表。只要我们不去调用 SessionStatus 的 setComplete() 方法,这个对象就会一直保留在 Session 中,从而实现 Session 信息的共享。

    controller的代码如下:

    Java代码 复制代码 收藏代码
    1. @Controller  
    2. @SessionAttributes("currentUser")  
    3. public class GreetingController{  
    4. @RequestMapping  
    5. public void hello(@ModelAttribute("currentUser") User user){  
    6. //user.sayHello()  
    7. }  
    8. //  
    9. }  
    @Controller
    @SessionAttributes("currentUser")
    public class GreetingController{
    @RequestMapping
    public void hello(@ModelAttribute("currentUser") User user){
    //user.sayHello()
    }
    //
    }

     
    使用这种方案,还需要在 SpringMVC 配置文件的 ViewResolver 定义处,加上 p:allowSessionOverride="true",这样如果你对 User 对象做了修改,SpringMVC 就会在渲染 View 的同时覆写 Session 中的相关属性。

    优点:

    1. 具备第二种方案的所有优点

    2. 使用 Annotation 声明对 Session 特定属性的存取,每个 action 只需要声明自己想要的 Session 属性。
    3. 其他人能很容易地从 action 的参数列表得知 action 所需要的依赖,API 更清晰易懂。

    不足:

    1. 对于相同属性的 Session 对象,需要在每个 action 上定义。
    2. 这种方案并不是 SpringMVC 的初衷,因此有可能会引起一些争议。


    纵观这四类方法,我们可以看出我们对 Session 属性的访问控制设置,是从所有 Servlet,到某一类型的 controller 的成员变量,到所有 action 的某一类型参数,再到具体 action 的具体对象。每种方案都有各自的优点和不足:第一种方案虽然精确,但可惜引入了对 Servlet API 的依赖,不利于 controller 的测试和逻辑复用。第二、三种方案虽然解决了对 Servlet API 的依赖,也分别在 controller 和 action 级别上提供了对 Session 属性的访问,但注入粒度在一定程度上还是不够细,要想对具体属性进行访问可能会比较繁琐。不过,这在另一方面也提供了简便而统一的方法来对一系列相同类型的参数进行注入。第四种方案通过使用 Annotation,不仅摆脱了 Servlet API 的依赖,而且在 action 级别上提供了对 Session 具体属性的访问控制。但是这种访问有可能会粒度过细,需要在很多不同 action 上声明相同的 annotation。而且,毕竟这种用法并不是 SpringMVC 的初衷和推荐的,可能会带来一些争议。

    本文演示了 Spring2.5 访问 Session 属性的几种不同解决方案,并分析了各自的优点和不足。本文并不打算对这些解决方案评出对错,只是试图列出在选择方案时的思维过程以及选择标准。每种方案都能满足某一类上下文的需求,在特定的开发环境和团队中都可能会是最优的选择。但是笔者还是发现,整个过程中,一些平常容易忽视的 OOP 的准则或者原则在发挥着效应,鉴于本文篇幅已经较长,就留到后续文章中继续探讨解决方案选择背后的深层含义,敬请期待。

    展开全文
  • 关于编码的理解

    2018-07-05 18:20:35
    一、字节关于编码的理解始于字节这一数据格式。整型转字节类型使用bytes()函数,其他进制转2进制使用bin()函数。1. 定义 字节是一系列单字节的组合,每一个字节都是[0, 255](无符号)范围内组成。 单字节:一个字节...

    一、字节

    关于编码的理解始于字节这一数据格式。整型转字节类型使用bytes()函数,其他进制转2进制使用bin()函数。

    1. 定义
        字节是一系列单字节的组合,每一个字节都是[0, 255](无符号)范围内组成。
        单字节:一个字节8个数据位

    2. 转换

    (1) 字符串和字节串的相互转化

        参考自:https://blog.csdn.net/baidu_19473529/article/details/80042582

     #bytes object
        byte = b"byte example"
    
        # str object
        str = "str example"
    
        # str to bytes 字符串转字节
        bytes(str, encoding="utf8")
    
        # bytes to str  字节转字符串
        str(bytes, encoding="utf-8")
    
        # an alternative method
        # str to bytes  字符串转为字节
        str.encode(str)
    
        # bytes to str  字节转为字符串
        bytes.decode(bytes)

    (2) 单字节(单字符串)和二进制(ASCII码)的转换 ---ord() / chr()

    # 用户输入字符
    c = input("请输入一个字符: ")
     
    # 用户输入ASCII码,并将输入的数字转为整型
    a = int(input("请输入一个ASCII码: "))
     
    print( c + " 的ASCII 码为", ord(c))
    print( a , " 对应的字符为", chr(a))

        运行结果:

    请输入一个字符: a
    请输入一个ASCII码: 101
    a 的ASCII 码为 97
    101  对应的字符为 e

     (3) 单字节(单字符串)和十进制的转换

    #字节串转整数:
    转义为short型整数: struct.unpack('<hh', bytes(b'\x01\x00\x00\x00'))  ==>  (1, 0)
    转义为long型整数: struct.unpack('<L', bytes(b'\x01\x00\x00\x00'))  ==>  (1,)
    #------------------
    #整数转字节串:
    转为两个字节: struct.pack('<HH', 1,2)  ==>  b'\x01\x00\x02\x00'
    转为四个字节: struct.pack('<LL', 1,2)  ==>  b'\x01\x00\x00\x00\x02\x00\x00\x00'

    二、 编码

    1. ASCII码


           是美国标准信息交换代码(American Standard Code for Information Interchange)的缩写, 为美国英语通信所设计。它由128个字符组成,包括大小写字母、数字0-9、标点符号、非打印字符(换行符、制表符等4个)以及控制字符(退格、响铃等)组成。

        ASCII 码的数字范围: 48 --- 57

                  大写字母范围: 65 --- 90

                  小写字母范围: 97 --- 122

    2. Unicode

        Unicode(统一码、万国码、单一码)是计算机科学领域里的一项业界标准,包括字符集、编码方案等。Unicode 是为了解决传统的字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,以满足跨语言、跨平台进行文本转换、处理的要求。

    3. UTF压缩过的(Unicode

            UTF-8是一种可变宽度 字符编码,能够使用一到四个8位字节对Unicode中的所有1,112,064 [1]个有效代码点进行编码。

        优势

            UTF-8最大的优势是,没有字节序的概念。所以特别适合用于字符串的网络数据传输,不用考虑大小端问题。对于非英文网页(对于我们而言,简单说东亚文字网页),能够避免各种乱码问题。

        劣势

            本地字符串处理过程中,如果使用UTF-8,对于英文字符的处理没有太大的问题。一个char变量表示一个英文字符。但是对于中文等远东字符集来说,就比较坑爹了。char str[]; str[0]并不能完整表示一个汉字。UTF-8编码格式下,一个汉字需要至少3个char才能表示。这对于通过下标来操作字符串的操作来说是非常痛苦的一件事情。

    4. GBK

            GBK编码,是在GB2312-80标准基础上的内码扩展规范,使用了双字节编码方案,其编码范围从8140至FEFE(剔除xx7F),共23940个码位,共收录了21003个汉字。




    展开全文
  • 关于 Goroutine Channel Select 用法和理解 阅读 384 收藏 13 2017-05-18 原文链接:blog.sodroid.com 转载请注明本文地址,感谢 :) 了解进程、线程、协程 本文不详细解释这三个名词意思,下面有一篇...
  • 那这篇博客主要是承接上面poll select epoll区别,上升到多线程、多进程高级IO复用区别了。 ... 那我们还是从代码开始说起,先看...使用多线程多进程也能够实现多个客户端服务器数据收发功能。那么...
  • 关于jvm帧栈理解

    千次阅读 2018-07-02 20:48:37
    参考 ... Java中栈 ...某个线程正在执行方法称为当前方法,当前方法使用的栈帧称为当前帧,当前方法所属类称为当前类,当前类常量池称为当前常量池。当线程执行一个方法时,它会跟踪当前常量池。 ...
  • 这是一个关于如何使用 Django REST Framework 使用 ModelViewSets Serializers 创建一个简单博客,如面向 API 服务器示例项目。 代码有一些有趣细节来帮助理解: 嵌套序列化程序,以及如何获取整个嵌套...
  • 在下面这篇博文中学习了race condition, http://blog.csdn.net/boyxulin1986/article/details/11704257 ...至于是使用互斥锁还是读写锁还是什么锁,根据需要而定即可。 但是锁用多了就有可能发生死锁。
  • http://eleda.iteye.com/blog/1108700 ... NSAutoreleasePool @autoreleasepool blocks 区别 /** xcode4.3引入ARC,release这块就有些变化,当你使用ARC,就必须将N
  • Node.js关于Stream的理解

    2020-12-08 19:35:53
    理解这两种模式对该种流的理解将更透彻。 流动模式,该模式下的流将会由底层系统自行调用,并尽可能快的提供给你的程序。简而言之,就是程序自动读取数据。 暂停模式,该模式下...
  • 转:https://blog.csdn.net/colayeah/article/details/54583499 Java语言是面向对象:Java语言提供类、接口...对于类之间单继承我们很好理解,是为了避免子类被引用时候同一个方法无法判断应该使用哪个父类...
  • 原文链接:https://blog.csdn.net/margin_0px/article/details/81740225 挂载: Liunx采用树形文件管理系统,也就是在Linux系统中,可以说已经没有分区...要使用一个分区必须把它...
  • 关于函数strtokstrtok_r的理解

    千次阅读 2012-11-29 11:36:22
    strtok函数的使用是一个老生常谈问题了。该函数作用很大,争议也很大。以下表述可能与一些资料有区别或者说与你原来认识有差异,因此,我尽量以实验为证。交代一下实验环境是必要,winxp+vc6.0,一个极端...
  • RWZI数据存在似是而非的理解,这段时间对其仔细了解了一番,发现了一些规律,理解了一些以前书本上有的但是不理解的东西,我想应该有不少人也有我同样的困惑,因此将我的一些关于RO,RWZI的理解写出来,希望能...
  • 线性表使用顺序(数组)存储时有个弊端,那就是在插入删除时需要大量移动数据,这显示是非常消耗时间,所以可以采用链式存储,即有一个指针域(单链表),来记录下个结点存储位置(地址),这样在插入删除...
  • 关于微前端一些浅显知识,主要是通过看别人文章来了解,blog记录内容别人文章会有重叠。 1.什么是微前端? 将不同功能分成多个子应用。 通过主应用来加载这些子应用。 核心:先拆后合 2.为什么要...
  • 证书主要文件类型协议有: PEM、DER、PFX、JKS、KDB、CER、KEY、CSR、CRT、CRL 、OCSP、SCEP等。 PEM – Openssl使用 PEM(Privacy Enhanced Mail)格式来存放各种信息,它是 openssl 默认采用信息存放方式。...
  • 关于http协议描述curl使用详解

    千次阅读 2017-12-23 15:34:20
    1、HTTP协议的理解: 1.1 首先提供几个自己在开发过程中查阅的网站 ·http://blog.csdn.net/kingcodexl/article/details/51306062 ·https://developer.mozilla.org/zh-CN/docs/Web 主要了解HTTP的报文格式以及...
  • 原文地址:http://blog.csdn.net/xunyn/article/details/13629071 一.UDID(Unique Device ...在很多需要限制一台设备一个账号应用中经常会用到,在Symbian时代,我们是使用IMEI作为设备唯一标识,可惜...
  • 关于编码一些理解

    2010-07-18 10:55:00
    tsoukw.cnblogs.com/archive/2006/07/13/449588.html<br />很久没有写blog了﹐今天下午工作刚好告一段落﹐有点时间﹐就把上周花了很多时间总结出来一些计算机字符相关心得写出来﹐希望能够帮助当初我一样迷茫...
  • 参考...Java虚拟机把描述类数据从Class文件加载到内存,并对数据进行校验、转换解析初始化,最终形成可以被虚拟机直接使用的Java类型,这就是虚拟机加载机制。 Clas...
  • 关于委托一些理解

    2007-10-19 10:10:00
    张子阳在他一篇blog中很详细介绍了 委托事件。 这篇文章由浅入深,让人看了后倍感清晰。 对于委托,我还有些自己疑问和理解,在这里写下。 委托定义:委托是一个类,它定义了方法类型,使得可以将...
  • 之前的blog中已经讲述了具体的类的定义,此处就不在赘述,这里讲一下关于我个人对类对象的理解 1. 类对象的理解 类: 其实时一个比较抽象的一个归类,并没有涉及到一个具体的事物,在现实中可以理解为一个类别...
  • 1、普通内部类可以调用可以使用外部类一切函数变量,也就是普通内部类回持有一份外部类对象也就是外部类要等内部类释放后才能得到内存释放所以耗时操作可以使用静态内部类。2、静态内部类:只能调用外部类...
  • 子类继承父类:可以继承父类私有属性方法,但是不能使用父类私有属性方法。解释:书本中是子类继承父类,子类拥有父类所有属性方法, 通过程序验证发现父类私有属性私有方法子类不能访问。 于是你...
  • 其实我一直准备写一篇关于Android事件分发机制文章,从我第一篇博客开始,就零零散散在好多地方使用到了Android事件分发知识。也有好多朋友问过我各种问题,比如:onTouchonTouchEvent有什么区别,又该如何...

空空如也

空空如也

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

关于blog的理解和使用