精华内容
下载资源
问答
  • C++ using关键字作用总结 原本想对using的用法进行一个总结的,不过发现已经有人这么做了,而且写得不错,就直接引用啦,感谢原文作者 原文链接: ... 1.当前文件引入命名空间 ...这是我们最熟悉的用法,例如:...

    C++ using关键字作用总结

    原本想对using的用法进行一个总结的,不过发现已经有人这么做了,而且写得不错,就直接引用啦,感谢原文作者

    原文链接:

    https://www.cnblogs.com/ustc11wj/archive/2012/08/11/2637316.html

     

    1.在当前文件中引入命名空间

    这是我们最熟悉的用法,例如:using namespace std;

     

    2.在子类中使用 using 声明引入基类成员名称(参见C++ primer)

    在private或者protected继承时,基类成员的访问级别在派生类中更受限:

    class Base {
    public:
    std::size_t size() const { return n; }
    protected:
    std::size_t n;
    };
    class Derived : private Base { . . . };

    在这一继承层次中,成员函数 size 在 Base 中为 public,但在 Derived 中为 private。为了使 size 在Derived 中成为 public,可以在 Derived 的 public
    部分增加一个 using 声明。如下这样改变 Derived 的定义,可以使 size 成员能够被用户访问,并使 n 能够被Derived的派生类访问:

    class Derived : private Base {
    public:
    using Base::size;
    protected:
    using Base::n;
    // ...
    };

    另外,当子类中的成员函数和基类同名时,子类中重定义的成员函数将隐藏基类中的版本,即使函数原型不同也是如此(隐藏条件见下面)。

    如果基类中成员函数有多个重载版本,派生类可以重定义所继承的 0 个或多个版本,但是通过派生类型只能访问派生类中重定义的那些版本,所以如果派生类想通过自身类型使用所有的重载版本,则派生类必须要么重定义所有重载版本要么一个也不重定义。有时类需要仅仅重定义一个重载集中某些版本的行为,并且想要继承其他版本的含义,在这种情况下,为了重定义需要特化的某个版本而不得不重定义每一个基类版本,可能会令人厌烦。可以在派生类中为重载成员名称提供 using 声明(为基类成员函数名称而作的 using 声明将该函数的所有重载实例加到派生类的作用域),使派生类不用重定义所继承的每一个基类版本。一个 using 声明只能指定一个名字,不能指定形参表,使用using声明将名字加入作用域之后,派生类只需要重定义本类型确实必须定义的那些函数,对其他版本可以使用继承的定义。

     

    “隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:

    1、如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)

    2、如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)

    #include "StdAfx.h"
    #include <iostream>
    using namespace std;
    
    class Base
    {
    public:    
       void menfcn()
      {
         cout<<"Base function"<<endl; 
      }
    
        void menfcn(int n)
        {
             cout<< cout<<"Base function with int"<<endl; 
        }
    
    };
    
    class Derived : Base
    {
    public:    
    using Base::menfcn;//using声明只能指定一个名字,不能带形参表    
    int menfcn(int)
    { 
        cout<< cout<<"Derived function with int"<<endl; }
    };
    
    int main()
    {    Base b; 
         Derived d;   
      b.menfcn();   
      d.menfcn();//如果去掉Derived类中的using声明,会出现错误:error C2660: 'Derived::menfcn' : function does not take 0 arguments    
    std::cin.ignore(std::cin.gcount()+1);//清空缓冲区    
    std::cin.get();//暂停程序执行  
    }

     

    展开全文
  • C#中using关键字作用及用法 1**. using的用途和使用技巧.  1、 引用命名空间  2、 为命名空间或类型创建别名  3、 使用using语句** 1、 引用命名空间,这样可以程序引用命名空间的类型而不必指定详细的命名...

    C#中using关键字的作用及用法

    1**. using的用途和使用技巧.
      1、 引用命名空间
      2、 为命名空间或类型创建别名
      3、 使用using语句**

    1、 引用命名空间,这样可以在程序中引用命名空间的类型而不必指定详细的命名空间.
        a) 比如在程序中常用的using System.Text;
        b) 引用命名空间,并不等于编译器编译时加载该命名空间所在的程序集,程序集的加载决定于程序中对该程序集是否存在调用操作,如果代码中不存在任何调用操作则编译器将不会加载using引入命名空间所在空间的程序集.因此,在源文件开头,引入多个命名空间,并非加载多个程序集,不会造成’过度引用’的弊端
      2、 为命名空间或类型创建别名
          创建别名的原因在于同一个文件中引入不同的命名空间中包括了相同名称的类型。为了避免出现名称冲突,可以通过设定别名来解决.
            例:using SGPoint = ShapMap.Geometries.Point
            Using SGPoint = System.Drawing.Point
          其实也可以通过类型全名称来加以区分,但是最佳解决方案还是使用using
      3、 using 语句
        using语句允许程序员指定使用资源的对象应当何时释放资源.using语句中使用的对象必须实现IDisposable接口.此接口提供了Dispose方法,该方法将释放此对象的资源
    使用规则:
          a) using语句只能用于实现了IDisposable接口的类型,禁止为不支持IDisposable接口类型使用using语句,否则会出现编译错误
          b) using语句适用于清理单个非托管资源的情况,而多个非托管对象的清理最好以try-finaly来实现,因为嵌套using语句可能存在隐藏的Bug.内层using块引发异常时,将不能释放外层using块的对象资源
    using实质:
    在程序编译阶段,编译器会自动将using语句生成try-finally语句,并在finally块中调用对象的Dispose方法,来清理资源.所以,using语句等效于try-finally语句

    展开全文
  • C++ using关键字作用

    2016-04-25 10:07:54
    2.子类使用 using 声明引入基类成员名称(参见C++ primer) 3. 当子类的成员函数和基类同名时,子类重定义的成员函数将隐藏基类的版本,即使函数原型不同也是如此(隐藏条件见下面),使用using声明,解除...

    1.在当前文件中引入命名空间

    这是我们最熟悉的用法,例如:using namespace std;

    2.在子类中使用 using 声明引入基类成员名称(参见C++ primer)

    在private或者protected继承时,基类成员的访问级别在派生类中更受限:

    class Base {
    public:
        std::size_t size() const { return n; }
    protected:
        std::size_t n;
     };
    class Derived :  private Base { . . . };

    在这一继承层次中,成员函数 size 在 Base 中为 public,但在 Derived 中为 private。为了使 size 在 Derived 中成为 public,可以在 Derived 的 public
    部分增加一个 using 声明。如下这样改变 Derived 的定义,可以使 size 成员能够被用户访问,并使 n 能够被 Derived的派生类访问:

    class Derived :  private Base {
    public:
        using Base::size;
    protected:
        using Base::n;
    // ...
    };

    3. 另外,当子类中的成员函数和基类同名时,子类中重定义的成员函数将隐藏基类中的版本,即使函数原型不同也是如此(隐藏条件见下面)

    如果基类中成员函数有多个重载版本,派生类可以重定义所继承的 0 个或多个版本,但是通过派生类型只能访问派生类中重定义的那些版本,所以如果派生类想通过自身类型使用所有的重载版本,则派生类必须要么重定义所有重载版本,要么一个也不重定义。有时类需要仅仅重定义一个重载集中某些版本的行为,并且想要继承其他版本的含义,在这种情况下,为了重定义需要特化的某个版本而不得不重定义每一个基类版本,可能会令人厌烦。可以在派生类中为重载成员名称提供 using 声明(为基类成员函数名称而作的 using 声明将该函数的所有重载实例加到派生类的作用域),使派生类不用重定义所继承的每一个基类版本。一个 using 声明只能指定一个名字,不能指定形参表,使用using声明将名字加入作用域之后,派生类只需要重定义本类型确实必须定义的那些函数,对其他版本可以使用继承的定义。

    “隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:

    1、如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)

    2、如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)

    #include "StdAfx.h"
    #include <iostream>
    using namespace std;
    
    class Base
     {
     public:    
        void menfcn()
        {
          cout<<"Base function"<<endl; 
        }
    
        void menfcn(int n)
        {
          cout<< cout<<"Base function with int"<<endl; 
        }
    
    };
    
    class Derived : Base
     {
     public:    
         using Base::menfcn;//using声明只能指定一个名字,不能带形参表    
         int menfcn(int)
         { 
             cout<< cout<<"Derived function with int"<<endl; 
         }
     };
    
    int main()
     {    Base b; 
          Derived d;   
          b.menfcn();   
          d.menfcn();//如果去掉Derived类中的using声明,会出现错误:error C2660: 'Derived::menfcn' : function does not take 0 arguments    std::cin.ignore(std::cin.gcount()+1);//清空缓冲区    
          std::cin.get();//暂停程序执行  
     }
    

    感谢,博文转载自http://www.cnblogs.com/ustc11wj/archive/2012/08/11/2637316.html

    展开全文
  • C#中using关键字作用及其用法

    万次阅读 2012-05-22 09:04:43
    C#中using关键字作用及其用法 using的用途和使用技巧。  using关键字微软MSDN上解释总共有三种用途:  1、引用命名空间。  2、为命名空间或类型创建别名。  3、使用using语句。  1、引用命名空间,这样就可以...
    C#中using关键字的作用及其用法
    
    using的用途和使用技巧。
        using关键字微软MSDN上解释总共有三种用途:
        1、引用命名空间。
        2、为命名空间或类型创建别名。
        3、使用using语句。
        1、引用命名空间,这样就可以直接在程序中引用命名空间的类型而不必指定详细的命名空间。
            这个就不用说了吧,比如大家最常用的:using System.Text;
        2、为命名空间或类型创建别名:
            当同一个cs引用了不同的命名空间,但这些命名控件都包括了一个相同名字的类型的时候,可以使用using关键字来创建别名,这样会使代码更简洁。注意:并不是说两个名字重复,给其中一个用了别名,另外一个就不需要用别名了,如果两个都要使用,则两个都需要用using来定义别名的。
            using System;
            using aClass = NameSpace1.MyClass;
            using bClass = NameSpace2.MyClass;
            ......
            //使用方式
            aClass my1 = new aClass();           
            Console.WriteLine(my1);
            bClass my2 = new bClass();
            Console.WriteLine(my2);


        3、使用using语句,定义一个范围,在范围结束时处理对象。(不过该对象必须实现了IDisposable接口)。其功能和try ,catch,Finally完全相同。

            比如:

            using (SqlConnection cn = new SqlConnection(SqlConnectionString)){......}//数据库连接
            using (SqlDataReader dr = db.GetDataReader(sql)){......}//DataReader
            PS:这里SqlConnection和SqlDataReader对象都默认实现了IDisposable接口,如果是自己写的类,那就要自己手动来实现IDisposable接口。比如:
            using (Employee emp = new Employee(userCode))
            {
               ......
            }
    Emlpoyee.cs类:        
    public class Employee:IDisposable
    {
           #region 实现IDisposable接口
            /// <summary>
            /// 通过实现IDisposable接口释放资源
            /// </summary>
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }
            /// <summary>
            /// 释放资源实现
            /// </summary>
            /// <param name="disposing"></param>
            protected virtual void Dispose(bool disposing)
            {
                if (!m_disposed)
                {
                   if (disposing)
                    {
                        // Release managed resources
                        if(db!=null)
                            this.db.Dispose();
                        if(dt!=null)
                            this.dt.Dispose();
                        this._CurrentPosition = null;
                        this._Department = null;
                        this._EmployeeCode = null;                
                   }
                    // Release unmanaged resources(释放非托管资源)
                    m_disposed = true;
                }
            }
            /// <summary>
            /// 析构函数
            /// </summary>
            ~Employee()
            {
                Dispose(false);
            }
            private bool m_disposed;
            #endregion
    }       

            使用using语句需要注意的几点:
            3.1、对象必须实现IDisposeable接口,这个已经说过,如果没有实现编译器会报错误。
                如: 
                using( string strMsg = "My Test" )
                {          
                    Debug.WriteLine( strMsg );//Can't be compiled
                }
    

            3.2、第二个using对象检查是静态类型检查,并不支持运行时类型检查,因此如下形式也会出现编译错误。   
             SqlConnection sqlConn = new SqlConnection( yourConnectionString );
             object objConn = sqlConn;
             using ( objConn )
             {
                Debug.WriteLine( objConn.ToString() );//Can't be compiled
             }

    不过对于后者,可以通过“as”来进行类型转换方式来改进。
            SqlConnection sqlConn = new SqlConnection( yourConnectionString );
            object objConn = sqlConn;
            using ( objConn as IDisposable )
           {
             Debug.WriteLine( objConn.ToString() );
           }
    

            3.3、当同时需要释放多个资源时候,并且对象类型不同,可以这样写:
            using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) )
            using( SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn ) )
            {
                sqlConn.Open();//Open connection
                //Operate DB here using "sqlConn" 
                sqlConn.Close();//Close connection
            }

            如果对象类型相同,可以写到一起:
            using (Font MyFont = new Font("Arial", 10.0f), MyFont2 = new Font("Arial", 10.0f))
           {
                // use MyFont and MyFont2
            }   // compiler will call Dispose on MyFont and MyFont2

            3.4、using关键字只是针对C#语句,对于VB等其他语言还没有对应的功能。

            关于.Net资源释放问题,也就是对于非内存的资源,最好使用IDisposable接口提供的Dispose来释放。
           很明显,Dispose方法是一个外部方法,系统并不会帮你调用。为了尽早释放对象所占用的资源,所以需要保证Dispose方法能尽早被执行。那么在.Net中提供了一个比较简便的方法,就是对于实现了IDisposable接口的类型对象提供了using语句。


    就操作一个数据库这个例子来说,使用using语句可以如下:
        using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) )
        {
            sqlConn.Open(); //Open connection  
            //Operate DB here using "sqlConn"
           sqlConn.Close(); //Close connection
        }

    但是有时候当多个对象需要释放的候,例如:
        SqlConnection sqlConn = new SqlConnection( yourConnectionString );
        SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn );
        using(sqlConn as IDisposable)
        using(sqlComm as IDisposable)
        {
           sqlConn.Open(); //Open connection  
            sqlComm.ExecuteNonQuery(); //Operate DB here
        }

           这时候要特别注意,需要确保在发生异常的情况下,所有对象都能正常释放。显然,这段程序块,当构造“sqlComm”对象发生异常,会造成 “sqlConn”对象无法及时被释放。虽说构造函数内部很少发生异常,或者说编写程序的时候要尽量避免从构造函数内向外散发异常。不过这里所说的意思是,要尽量把需要释放的对象放到using或者try-catch程序块,并作局部的异常处理,避免异常造成有些对象没有被释放。那么改进的方法,例如可以如下。

        using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) )
        using( SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn ) )
        {
            try
            {
                sqlConn.Open(); //Open connection
               sqlComm.ExecuteNonQuery(); //Operate DB here
            }
            catch( SqlException err )
            {
    
                MessageBox.Show( err.Message );
            }
            catch( Exception err )
            {
                MessageBox.Show( err.Message );
            }
        }

    (如上,即使在构造“sqlComm”出现异常,也会释放“sqlConn”对象。同时在这里多谢 lmtz 网友对文章提出的异议,从而使我重新审查此文,并进行修正。)

    但是对于using程序块来说,它有两个限制。
           第一个就是using所对应的对象必须继承IDisposable,如果此对象没有继承IDisposable接口的话,系统会提示编译错误。
    例如:
     
      using( string strMsg = "My Test" )
            Debug.WriteLine( strMsg ); //Can't be compiled
    第二个using对象检查是静态类型检查,并不支持运行时类型检查,因此如下形式也会出现编译错误。
        SqlConnection sqlConn = new SqlConnection( yourConnectionString );
        object objConn = sqlConn;
        using ( objConn )
        {
            Debug.WriteLine( objConn.ToString() ); //Can't be compiled
        }
        不过对于后者,可以通过“as”来进行类型转换方式来改进。
        SqlConnection sqlConn = new SqlConnection( yourConnectionString );
        object objConn = sqlConn;
        using ( objConn as IDisposable )
        {
            Debug.WriteLine( objConn.ToString() );
        }

         对于Dispose函数的调用来说,使用using程序块来完成只是最常用的方法,除此外,还可以用try-finally来完成,例如:
        SqlConnection sqlConn = new SqlConnection( yourConnectionString );
        try
        {
            sqlConn.Open();      
            //Operate DB here using "sqlConn"
        }
        finally
        {
            if( sqlConn != null )
                sqlConn.Dispose();
        }
           为了及早释放对象所占用的非托管资源,因此要保证Dispose方法能在使用完对象后被调用,.Net提供了using程序块和try-finally程序块两个方法,两者并没有太大的区别,可能使用using能使程序看得比较简明,但是为了防止异常,需要在using中加入try-catch,这样反而不如try-finally看得舒服,不过这也只是我个人的看法。总的来说,只要把方法合理整合到应用程序当中才是最重要的。
    public   DataSet   GetRoleList()  
      {  
            using(DataSet   roles=RunProcedure("sp_Accounts_GetAllRoles",new IDataParameter[]{},"Roles"))  
       
            {  
              return   roles;  
            }  
      }  
      using   的作用我记得是这样的。using后面的括号表示这里面有重要的资源产生,using下面的   {}表示在这段代码运行完后释放掉那个  

    展开全文
  • c语言中extern关键字In this article, we’ll take a look at understanding the extern keyword in C. 本文,我们将了解C中的extern关键字。 This is primarily used when you have multiple source files, ...
  • C语言第四讲,typedef 关键字,以及作用域一丶typedef关键字在C语言中,有typedef关键字,这个关键字作用就是允许你为类型定义一个新的名字,也就是起个别的名字例如:typedef unsigned int DWORD那么以后,我们定义...
  • c#using关键字作用

    2019-06-10 13:28:48
    using关键字的三种作用: 1. 引用命名空间; 2. 为命名空间或者类型创建别名; 3. 使用using语句。 (1)引用命名空间 类似于c和c++的#include<>, python的import,都是程序引入命名空间的类型,而...
  • 2.子类使用 using 声明引入基类成员名称(参见C++ primer) private或者protected继承时,基类成员的访问级别派生类更受限: class Base { public: std::size_t size() const { re
  • c#中using关键字

    2014-04-09 14:12:21
    1、普通用法 using system; 2、使用别名 using class1 = namespace1.
  • /* run this program using the console pauser or add your own getch, system("pause") or input loop */ const int* func() { static int count=0; count++; return &count; } int main(int argc, char *...
  • c++ using 关键字

    2015-09-10 22:29:17
    C++ using关键字作用总结 1.当前文件引入命名空间 这是我们最熟悉的用法,例如:using namespace std; 2.子类使用 using 声明引入基类成员名称(参见C++ primer) private或者protected继承...
  • C#中using关键字的使用

    2019-09-04 10:11:57
    检查过程发现,虽然没有直接使用Close()方法,但执行连接数据库时使用了using关键字,然后验收人员便说没有问题 。为什么没有使用Close()方法,仅有using关键字也是可以的呢?于是上网查了相关的资料,...
  • C++和C语言中const关键字的区别 ** 1. 内存读取的区别 先来看下面的代码 const int m = 10; int n = m; C++的const关键字更像是编译阶段的#define。 在C语言中,编译器会先到 m 所在的内存取出一份数据,再将这份...
  • using关键字的使用

    2015-12-10 11:17:31
    using namespace std和使用Eigen等一些库的时候,经常看到使用using关键字using关键字在C++11之前和C++11之后的含义不一样。using的作用是把后面的那个item放到当前的作用。 C++11之后using的使用1.引入...
  • 在c语言中,register修饰的变量不能取地址,但是c++里面做了内容: 1、register关键字的变化: (1)register关键字请求“编译器”将局部变量存储于寄存器C语言中无法取得register变量地址,C++可以取得...
  • C#中using关键字的使用介绍

    千次阅读 2008-07-07 22:00:00
    对于using关键字,可能大家比较熟悉的是引入包的功能如代码:using System;还有一种方法和上面的使用方法较类似,只是我们可以指定一个别名,代码如:using INet = System.Net;最后一种用法则主要用于释放对象占用的...
  • mysqlusing关键字

    千次阅读 2019-08-21 20:03:44
    今天做数据库练习题时,突然发现以前没有注意过的一个问题,多表连接时最后的查询结果有重复的属性列怎么去重,大家都知道,多表连接时比较的分量必须是相同的属性组,两个表连接之后,select出所有的属性列,...
  • 使用命名空间 编程过程有很多的类名和函数名,很容易重复,...using library::function //作用使用function函数时,会调用library库的该函数 //当同一个函数使用的多个库有命名重复时,编译器会报错,
  • 第一次写博客,可能排版没那么好,也不知道会不会有读者,权当给自己看吧先,如果有...//这样定义的目的经常是为了定义一个全局性的、值不能被改变的“常量”,作用类似于# define MAX 100 还有另一种定义格式: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 120,975
精华内容 48,390
热门标签
关键字:

在c中using关键字的作用