文档章节

4.C#变量

eddy_linux
 eddy_linux
发布于 2017/07/27 12:32
字数 3263
阅读 3
收藏 0
/*
 类型转换
    隐式转换:从类型A到类型B的转换可以在所有情况下进行,进行转换的规则非常简单,可以让编译器执行转换
    显示转换:从类型A到类型B的转换只能在某些情况下进行,转换的规则比较负责,应进行某种类型的处理

    隐式转换:不需要做任何工作,也不需要编写额外代码
    ushort destinationvar;
    char sourcevar = 'a';
    destinationvar = sourcevar
    Console.WriteLine(sourcevar)
    Console.WriteLine(destinationvar)
    结果就是a和97
    这样destinationvar和sourcevar就做了隐式转换没有编写额外代码,但是要注意不同的类型最后展现的结果也会不一样的,因为数据类型不一样了
    bool和string没有隐式转换,下面列出一些隐式转换的列表
    byte--------------》short,ushort,int,unit,ulong,float,dobule,decimal
    sbyte-------------》ushort,int,long,float,dobule,decimal
    short-------------》int,long,float,dobule,decimal
    ushort------------》int,unit,long,float,dobule,decimal
    int---------------》long,float,dobule,decimal
    uint--------------》long,ulong,float,dobule,decimal
    long--------------》float,dobule,decimal
    ulong-------------》float,dobule,decimal
    float-------------》dobule
    char--------------》ushort,int,unit,long,ulong,float,dobule,decimal
    有一个规则,任何类型A,只要起取值范围完全包含在类型B的取值范围内,就可以隐式转换为类型B

    显示转换:在明确要求编译器把数值从一种数据类型转换为另一种数据类型时
    就是在执行显示转换,因此需要另外编写代码。
    byte destinationvar;
    short sourcevar = 7;
    destinationvar = sourcevar
    Console.WriteLine(sourcevar)
    Console.WriteLine(destinationvar)
    如果编译这段就会产生错误
    cannot implicitly convert type 'short' to 'byte'..........
    C#编译器可以检测出没有进行显示转换
    为了成功编译这段代码需要田间显示转换的代码,最简单的方式把short变量强制转换为byte
    强制转换就是强迫数据从一种类型转换为另一种类型,其语法比较简单
    <(destinationtype)sourcevar>
    就是把sourcevar的值转换为destinationtype
    byte destinationvar;
    short sourcevar = 7;
    destinationvar = (byte)sourcevar
    Console.WriteLine(sourcevar)
    Console.WriteLine(destinationvar)
    现在可以转换是因为7也在byte的范围内(<=255)
    纳闷如果超过255该怎么编写?
    首先如果依然按照上面的进行转换那么会产生数据丢失的情况
    因为已经超过byte最大的保存数值了
    这里就要用到两个关键字checked和unchecked,叫做表达式的溢出检查
    checked(experssion)
    unchecked(experssion)

    byte destinationvar;
    short sourcevar = 281;
    destinationvar = checked((byte)sourcevar)
    Console.WriteLine(sourcevar)
    Console.WriteLine(destinationvar)

    还有一种可以使用convert进行转换
    但是需要确定首先转换范围不会溢出
            Convert.ToBoolean(val);     var---》bool
            Convert.ToByte(var);        var---》byte
            Convert.ToChar(val);        var---》char
            Convert.ToDecimal(var);     var---》decimal
            Convert.ToDouble(var);      var---》double
            Convert.ToInt16(var);       var---》short
            Convert.ToInt32(var);       var---》int
            Convert.ToInt64(var);       var---》long
            Convert.ToSByte(var);       var---》sbyte
            Convert.ToSingle(var);      var---》float
            Convert.ToString(var);      var---》string
            Convert.ToUInt16(var);      var---》ushort
            Convert.ToUInt32(var);      var---》uint
            Convert.ToUInt64(var);      var---》ulong
            其中var可以是大多数变量类型,对于转换总要进行溢出检查
 */
#region
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 变量
{
    class Program
    {
        static void Main(string[] args)
        {
            short shortresult, shortval = 4;
            int integerval = 67;
            long longresult;
            float floatval = 10.5F;
            double doubleresult, doubleval = 99.999;
            string stringresult, stringval = "17";
            bool boolval = true;
            Console.WriteLine("variable conversion example\n");
            doubleresult = floatval * shortval;
            Console.WriteLine("implicit->double:{0}*{1}->{2}", floatval, shortval, doubleresult);

            shortresult = (short)floatval;
            Console.WriteLine("explicit->short:{0}->{1}", floatval, shortresult);

            stringresult = Convert.ToString(boolval) + Convert.ToString(doubleval);
            Console.WriteLine("explicit->string:\"{0}\" + \"{1}\"->{2}",boolval,doubleval,stringresult);

            longresult = integerval + Convert.ToInt64(stringval);
            Console.WriteLine("mixed->long:{0} + {1} -> {2}", integerval, stringval, longresult);
            Console.ReadKey();


        }
    }
}
#endregion
/*
这个示例包含前面所有的类型转转,例如shortval * floatval
其中一个short值和一个float值相乘,这样的指令中没有指定显示转换,应在可能的情况下
进行隐式转换,在这个示例中唯一有意义的隐式转换是把short转换为float

负责的变量类型:
    枚举
        有时希望变量提取的是以固定的集合中的值,例如,orientation类型可以存储north,south,east,west
        中的一个值此时就可以使用枚举类型注意有一个附加的步骤,不是仅仅声明一个给定类型的变量
        而是声明和描述一个用户定义的类型,在声明新类型的变量
        定义枚举:
            enum <typeName>
                {
                <value1>,
                <value2>,
                <value3>,
                .
                .
                .
                <valueN>,

                }
        接着声明新类型的变量
            <typeName> <varName>;
        并赋值:
            <varName> = <typeName><value>
        枚举使用一个基本类型来存储,美剧类型可以提取每个值都存储为该基本类型的一个值,默认为int
        在枚举的声明中添加类型就可以指定其他基本类型
            enum <typeName> : <underlyingType>
                {
                <value1>,
                <value2>,
                <value3>,
                .
                .
                .
                <valueN>,

                }
        枚举的基本类型可以是byte,sbyte,short,ushort,int,uint,long,ulong
        在默认的情况下每个值都会根据定义的顺序从0开始自动赋值给对应的基本类型
        这意味着value1=0,valur2=1可以重写这个赋值过程使用=并指定每个枚举的实际值
        没有赋值的任何值都会自动的获得一个初始值,这个初始值就是上一个明确声明值大1


    结构
    数组
*/

//枚举
namespace my
{
    enum orientation : byte
    {
        north = 1,
        south = 2,
        east = 3,
        west = 4
    }
    class Program
    {
        static void Main(string[] args)
        {
            orientation myDirection = orientation.north;
            Console.WriteLine("myDirection = {0}", myDirection);
            Console.ReadKey();
        }
    }
}

namespace my1
{
    enum orientation : byte
    {
        north = 1,
        south = 2,
        east = 3,
        west = 4
    }
    class Program
    {
        static void Main(string[] args)
        {
            byte directionByte;
            string directionString;
            orientation myDirection = orientation.north;
            Console.WriteLine("myDirection = {0}", myDirection);
            directionByte = (byte)myDirection;
            directionString = Convert.ToString(myDirection);
            Console.WriteLine("byte equivalent = {0}", directionByte);
            Console.WriteLine("string quivalent = {0}", directionString);
            Console.ReadKey();
        }
    }
}
/*
 结构
    结构就是由基哥数据组成的数据结构,这些数据可能具有不用类型,
    orientation myDirection
    double myDirection
    使用这样两个变量,是没有错误的,但是在一个地方存储这些信息应该更为简单
    定义结构
        使用struct
        struct <typeName>
        {
            <memberDeclarations>
        }
        <memberDeclarations>部分包含变量的声明,其格式与往常一样,每个成员的声明都采用如下形式
        <accesslibility> <type> <name>;
        要让调用结构的代码访问该结构的数据成员,可以对<accesslibility>使用关键字public,
        struct route
        {
        public orientation direction;
        public double distance;

        }
        定义了结构类型后,就可以定义新类型变量,来使用结构
        route myRoute;
        还可以通过句点字符访问这个组合变量中的数据成员
        myRoute.direction = orientation.north;
        myRoute.distance = 2.5;
 */
namespace mystruct
{
    enum orientation : byte
    {
        north = 1,
        south = 2,
        east = 3,
        west = 4
    }
    struct route
    {
        public orientation direction;
        public double distance;
    }
    class Program
    {
        static void Main(string[] args)
        {
            route myRoute;
            int myDirection = -1;
            double myDistance;
            Console.WriteLine("1) North\n2) South\n3)East\n4) West");
            do
            {
                Console.WriteLine("Selecr a direction:");
                myDirection = Convert.ToInt32(Console.ReadLine());
            }
            while ((myDirection < 1) || (myDirection > 4));
            Console.WriteLine("Input a distance:");
            myDistance = Convert.ToDouble(Console.ReadLine());
            myRoute.direction = (orientation)myDirection;
            myRoute.distance = myDistance;
            Console.WriteLine("myRoute specifies a direction of {0} and a" + "distance of {1}", myRoute.direction, myRoute.distance);
            Console.ReadKey();
        }
    }
}
/*
 结构和枚举一样也是在代码的主体之外声明的,在名称空间声明中声明route结构及其使用的orientation枚举
 enum orientation : byte
    {
        north = 1,
        south = 2,
        east = 3,
        west = 4
    }
    struct route
    {
        public orientation direction;
        public double distance;
    }
    代码的主题结构和前面的例子类似,要求输入一些信息并显示他们,把方向选项放在do循环中,对于用户的输入进行有效性检测
    拒绝不属于1-4范围的整数输入,注意在引用route成员时,处理他们的方式与成员类型相同的变量完全一样
    myRoute.direction = (orientation)myDirection;
    myRoute.distance = myDistance;
    可以直接把输入的值放到myRoute.distance中
    myRoute.distance = Convert.ToDouble(Console.ReadLine());
    还应进行有效性验证,但这段代码不存在这一步骤,对结构成员的任何访问都以相同的方式处理

数组
    前面的类型有一个共同特点,它们值存储一个值,有时需要存储许多数据,这样就带来不方便
    有时需要同时存储几个类型相同的值而不是每个值使用不同的变量

    鉴定要对所有朋友的名字进行一些操作
    string firendName1 = "Robert Barwell";
    string firendName2 = "Mike Parry";
    string firendName3 = "Jeremy Beacock";
    但这看起来需要很多工作,特别是需要编写不同的代码来处理每个变量,例如不能在循环中
    迭代这个字符串列表
    另一种方式使用数组,数组是一个变量的索引列表,存储在数据类型的变量中,例如一个数组friendName
    存储上述3个名字,在方括号中指定索引即可访问各个成员
    firendName[<index>]
    这个索引是一个整数第一个索引是0,第二个索引是1以此类推,这样就可以使用个循环遍历所有元素
    int i;
    for (i = 0; i < 3; i++)
    {
    Console.WriteLine("Name with index of {0}:{1}",i,firendName[i]);
    }
    声明数组
    <basetype>[] <name>;
    其中<basetype>可以是任何变量类型,数组必须在访问之前初始化
    int[] myintarray;
    myintarray[10] = 5;
    上面两行不能访问错误
    数组的初始化有两种方式,可以以字面形式指定数组的完整内容,也可以指定数组大小,在使用
    关键字new初始化所有数组元素
    使用字面值指定数组,只需要提供一个用逗号分隔的元素值列表,该列表放在花括号中,
    int[] myintarray = {1,3,5,2,99};
    其中myintarray有5个元素,每个元素都赋予了一个整数值
    另一种方式
    int[] myintarray = new int[5];
    这里使用关键new显示的初始化数组,用一个常量值定义其大小,这种方式会给所有的数组元素
    赋予同一个默认值,对于数值类型来说,其默认值是0
    还可以两种结合一起
    int[] myintarray = new int[5] {1,3,5,2,99};
    这种方式数组大小必须与元素个数相匹配,不能向下面这种
    int[] myintarray = new int[10] {1,3,5,2,99};
 */
namespace myarray
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] firendName = { "Robert Barwell", "Mike Parry", "Jeremy Beacock" };
            int i;
            Console.WriteLine("Here are {0} of my firends;", firendName.Length);
            for (i = 1; i < firendName.Length; i++)
            {
                Console.WriteLine(firendName[i]);
            }
            Console.ReadKey();
        }
    }
}
/*
 foreach
    foreach循环可以使用一种简便的语法来定位数组中的每个元素
    foreach (<baseType> <name> in <array>)
    {
    //can use <name> for each element
    }
    这个循环会迭代每个元素,依次把每个元素放在变量<name>中且不存在访问非法元素的危险
    不需要考虑数组中有多少个元素,使用这个循环可
 */
namespace myarray1
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] firendNames = { "Robert Barwell", "Mike Parry", "Jeremy Beacock" };
            int i;
            Console.WriteLine("Here are {0} of my firends;", firendNames.Length);
            foreach (string friendName in firendNames )
            {
                Console.WriteLine(friendName);
            }
            Console.ReadKey();
        }
    }
}
/*
 这段代码输出结构和前面的完全相同使用这种方法和标准的for循序主要的区别在于foreach循环
 对数组内容进行只读访问,所以不能任何元素值例如不能编写如下代码
 foreach (string friendName in firendNames )
 {
    friendName = "rupert the bear";
 }
 使用for循环就可以给数组元素赋值
 

多维数组
    声明
        二维数组
        <baseType>[,] <name>;
        多维数组只需要更多的逗号
        <baseType>[,,,] <name>;
        该语句声明一个4维数组,赋值也使用类似语法,用逗号分隔大小,
        例如要声明和初始化二维数组a基本类型double,x=3,y=4
        double[,] a = new double[3,4];
        还可以使用字面值进行初始的赋值
        double[,] a = {{1,2,3,4},{2,3,4,5},{3,4,5,6}};
        这个数组的维度与前面的相同也是3行4列,通过提供字面值隐式定义这些维度
        要访问多维数组中的每个元素需要指定它们的索引
        例如
        a[2,1]值为4
数组的数组
a = new int[2][];
a[0] = new int[3];
a[1] = new int[4];
也可以使用上述字面赋值的一种改进形式
a = new int[3][] {new int[] {1,2,3}, new int[] {1},new int[] {1,2}};
还可以简化成把数组的初始化和声明放在同一行
int[][] a = { new int[] {1,2,3}, new int[] {1}, new int[] {1,2}};
对于锯齿数组可以使用foreach循环,但是通常需要使用嵌套
下面代码会失败
foreach (int divisor in divisors1to10)
{
    Console.WriteLine(divisor);
}
因为数组divisors1to10包含int[]元素而不是int元素必须循环每个子数组和数组本身
foreach (int[] divisorOfInt in divisors1to10)
{
    foreach (int divisor in divisorOfInt)
    {
       Console.WriteLine(divisor);
    }
}
可以看出使用锯齿数组的语法复杂的多,需要根据实际情况来定义和使用


字符串的处理
目前对字符串的使用仅限于把字符串写到控制台上,从控制台上读取字符串,以及使用+运算符连接字符串
首先要注意,string类型变量可以看作char变量的只读数组
string mystring = "a string";
char mychar = mystring[1];
但是不能使用方式为各个字符赋值,为了获得一个可写的char数组,
string mystring = "a string";
char[] mychar = mystring.ToCharArray();
接着就可以采用标准方式处理char数组了也可以在foreach使用字符串
foreach (char character in mystring)
{
Console.WriteLine("{0}",character);
}
与数组一样还可以使用mystring.Length获取元素的个数
string mystring = Console.ReadLine();
Console.WriteLine("You typed (0) characters",mystring.Length);
其他的基本字符串处理技巧采用这种方式
例如<string>.ToLower(),<string>.ToUpper()
还有输入的时候无意在前面或后面添加了额外的空格
<string>.Trim()来处理
<string>.TrimStart()来处理首部的空格
<string>.TrimEnd()来处理结尾的空格
<string>.PadLeft(N)在左边添加N个空格
<string>.PadLeft(N,'-')在左边添加N个'-'
<string>.PadRight(N)在右边添加N个空格
 */

 

© 著作权归作者所有

共有 人打赏支持
上一篇: 5.C#函数-1
下一篇: 3.C#流程控制
eddy_linux
粉丝 22
博文 135
码字总数 188789
作品 0
成都
程序员
私信 提问
C语言基础单词计数问题?求救,急急急!!!

//这是一个计算字符数 ,单词数,行数的小算法,但是在vc++6.0中运行出现编译错误 //感觉上应该没有问题呀!求救!! #include #define OUT 0; #define IN 1; main () { int c ; int nl,nw,...

李英杰
2012/10/15
408
5
C/C++面试小知识点

1.static有什么用途。 解答: 在函数体中,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所有函数访问,但不...

长征4号
2017/09/20
0
0
第8章 函数(二)工程的诞生

在上一节中,我们将3个程序文件file1.c、file2.c、file3.c合并成了file4.c(即程序4),程序4中有4个函数:1个主函数,3个子函数。 合并过程简单描述就是: 1、file1.c、file2.c、file3.c拷贝...

日久不生情
2017/11/22
0
0
C语言超级搞笑的代码,冷笑话我们程序员也会讲的啊!

百年修得足下点击本文 欢迎来到"C语言基础"专题,今天我们放松一天,不学习知识,来看下大千世界的千奇百怪的C语言代码,你见过那些? 1.关于随机数这回事 这个随机数有点意思哦。 2.真亦假,...

艾艾贴
2018/07/14
0
0
二维码解码动态库API包

【业务需求】 QRCode 信息量 1K字节以内 分辨率 960*480 纠错等级 0(最低) 动态版本 支持信息量的最小版本 解码速率单线程每秒最低300张二维码图片 【人员要求】 C++或C语言 【交付要求】 1....

suzitai
2017/01/10
4
0

没有更多内容

加载失败,请刷新页面

加载更多

Spring Boot 集成 Swagger,生成接口文档就这么简单!

之前的文章介绍了《推荐一款接口 API 设计神器!》,今天栈长给大家介绍下如何与优秀的 Spring Boot 框架进行集成,简直不能太简单。 你所需具备的基础 告诉你,Spring Boot 真是个牛逼货! ...

Java技术栈
24分钟前
3
0
一个简单的js作用域题目(原创)

var name = 'nnmm' var obj = { name: 'name1', func: () => { console.log(this.name) }, func1: function (){ console.log(this.name) }, son: { ......

boogoogle
27分钟前
2
0
SSM整合activeMQ/activeMQ配置

一、引入依赖 <!-- xbean 如<amq:connectionFactory /> -->    <dependency>        <groupId>org.apache.xbean</groupId>        <artifactId>xbean-spring</artifac......

嘴角轻扬30
31分钟前
2
0
小公司出身的程序员,面试咋这么难?!

小公司出身,被大厂竞争者 KO 以下是一个非常真实的案例,是一个大厂工程师和一个小公司工程师同时求职一个独角兽公司的职位的经历。 一个是985本科学历,出身互联网大厂,四五年经验的样子。...

编程SHA
37分钟前
2
0
揭秘:蚂蚁金服bPaaS究竟是什么?

摘要: 分布式金融核心套件,蚂蚁金服bPaaS究竟是什么东东? 文/图 孙浩峰 去年9月,蚂蚁金服在杭州云栖ATEC发布了分布式金融核心套件bPaaS( Business Platform As a Service ),对外开放自...

阿里云官方博客
38分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部