C基础语法大全.doc

一， 注释语句
　　/**//*注释语句包含在"反斜杠* "和" *反斜杠"中，
　　或者两个反斜杠和换行符之中，
　　或者三个反斜杠和换行符之中(可以被VS自动识别为文件注释以提取)
　　要注意注释中的\，该续行符会把下一行连上来一起注释掉出错。*/
　　static
 void Main（string［］ args）
　　　　｛//语句块包含在｛｝中
　　　　　　int MyInterger;//语句以;结束
　　　　　　string   MyString;/**////忽略空白字符(空格/回车/TAB)
　　　　　　MyInterger = 17;
　　　　｝
　　//要注意防止注释嵌套出错，可用#if,#endif预处理语句。
二，数据类型
　　１，基本型/内置型  用户自定义型
　　Ａ，内置类型：CS使用.net FrameWork库中的数据类型
　　sbyte
 = System.SByte,...
类型  字节数  解释
byte  1  无符号字节型
sbyte  1  有符号字节型
short  2  有符号短字节型
ushort  2  无符号短字节型
int  4  有符号整型
uint  4  无符号整型
long  8  有符号长整型
ulong  8  无符号长整型
float  4  浮点数
double  8  双精度数
decimal
 8  固定精度数
string    unicode字串型
char    unicode字符型
bool    真假布尔型//只接受true和false两种值。不接受任何整数类型。
Ｂ，用户定义类型包括：
类类型(class)
结构类型(struct)
接口类型(interface)
　　２，值类型（Value Types）和引用类型（Reference Types）
　　Ａ，值类型：内存顺序分配在栈中。他们包括：所有基本或内置类型（不包括string类型）、结构类型、枚举类型(enum type)
　　Ｂ，引用类型：内存非线性分配在堆中，当它们不再被使用时CS通过垃圾收集器自动释放内存(C++用delete)。它们使用new运算符来创建。
　　引用类型包括：类类型、接口类型、象数组这样的集合类型类型、字串类型、枚举类型
　　结构型适于快速访问和拥有少量成员的数据类型。如果涉及量较多，你应该创建一个类来实现他。
　　３，数据类型转换
　　隐式转换:从低精度的转换到高精度的，所以不可能转换到char；另外可以把0隐式转换成枚举型，其他整数不行。
　　显式转换
        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 Examples\n数据类型转换范例\n"）;
            doubleResult = floatVal * shortVal;
            Console.WriteLine（"Implicit,->double:｛0｝*｛1｝->｛2｝", floatVal, shortVal, doubleResult）;
            shortResult = （short）floatVal;
            Console.WriteLine（"Implicit,->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）;

        ｝
三，变量：
　　１，普通变量：
　　(1),命名规则：字母或_或@ + 字母或_或数字 (/用于转义，@用于逐个转义指定,@常用于保留关键字前以保持与其他语言兼容)
　　(2),声明变量： 变量类型 变量名
　　变量赋值：变量 = 要赋的值
　　C#变量被访问之前必须被初始化；否则编译时会报错。因此，不可能访问一个未初始化变量(如不确定的指针、超出数组边界的表达式)。变量在使用前最好习惯是要先声明和初始化。
　　(3)C#中没有全局的的变量或全局函数，全局方式的操作是通过静态函数和静态变量来实现的。
int i;
string text;//在循环外未初始化
for (i =
 0;i<10;I++)
...{
  text =
  "Line"
  + Convert.ToString(i);//在循环中未初始化，在退出循环的时候会丢失值，再引用就出错。
  Console.WriteLine("{0},text);
}
Console.WriteLine("Last txet output in loop:{0},text);//出错。改正方法是在循环外初始化：string text="";
　　(4)命名约定：简单的用camelCase,复杂的用PascalCase
　　(5)变量的七种类型:
class A
...{
  public
  static
  int x;//静态变量,存在期从类装载直到该程序结束。
  int y;//非静态变量，或实例变量,从类实例创建到实例空间释放。

  /**//*v[0]是数组元素，a是值参数，b是引用参数，c是输出参数 */
  void F(int[] v,int a,ref
  int b,out
  int c)...{
    int i =
   1;//局部变量，不会被初始化
    c = a + b++;//
  }
}
　　２，枚举
　　　　enum 枚举名:枚举值类型（默认是int，默认赋值0,1,2...）
　　　　｛
　　　　　枚举值1=...,
　　　　　枚举值2=...,
　　　　　枚举值3,//不赋值的话，默认为最后一个明确具体值的值+1
　　　　　...
　　　　｝
　　　　枚举名 变量名＝枚举名.枚举值
namespace Ch05Ex02
...{
  enum orientation:byte
  ...{
    north=1,
    south=2,
    east=3,
    west=4
  }
/**////Class1's Desciption
class Class1
  ...{
  static
   void Main(string［］ args)
    ...{
        byte directionByte;
        string directionString;
        orientation myDirection = orientation.north;
        Console.WriteLine("mydirection = {0}", myDirection);
        directionByte = (byte)myDirection;//因为enum存得下byte,所以理论上可以正确地反过来转换，但逻辑上不一定正确。myDirection = (orientation)myByte;
        directionString = Convert.ToString(myDirection);//等价命令是directionString = myDirection.ToString();
//因为不单是把枚举变量值转存到string变量中，所以不能用string(mydirection);
//反向转换命令是orientation myDirection = (orientation)Enum.Parse(typeof(orientation),myString);但由于enum不一定存得下 string，所以可能出错。如myString赋值为North，就不能映射到orientation中的north，出错。
        Console.WriteLine("byte equivalent = {0}", directionByte);
        Console.WriteLine("string equivalent = {0}", directionString);
    }
  }
}　　　　
　　３，结构
　　　　struct 结构名:
　　　　｛
　　　　　访问方式1 变量类型1 变量名1;//访问方式public/private
　　　　　访问方式2 变量类型2 变量名2;　　
　　　　　...
　　　　｝
　　　　结构名 结构变量名;
　　　　结构变量名.枚举值=...;
　　４，一维数组
　　　　变量类型［］ 数组名 =
 new 变量类型[元素个数]...{元素0,元素1,元素2...}//元素个数必须是整数或者整数常量，而且必须与后面的元素列值个数相同，否则出错。元素个数的new声明和后面的元素列值可以只选一个，就能声明并初始化数组。
　　　　遍历方法
Ａ，For循环到.Length
for(i=0,i<friendNames.Length,i++)
...{
  Console.WriteLine(friendNames［i］);
}
Ｂ，Foreach进行只读访问
foreach(string listName in friendNames)
...{
  Console.WriteLine(listName);
}
　　５，二维数组(多维)
　　　　变量类型［,］ 数组名 =
 new 变量类型[一维元素个数,二维元素个数]...{...{元素00,元素01,元素02...},...{元素10,元素11,元素12...}...}
　　６，直角数组(交错数组,数组中的数组)
　　７，字符串操作：
string myString =
 "I have a dream.";
char myChar = myString［2］;//把string变量当作只读的char数组使用，不能改写myString［2］
char［］ myChars = myString.ToCharArray();

char［］separator = ｛'
 '｝;//设定分隔符
string［］ myWords =myString.Split(separator);//分隔成数组
Console.WriteLine("myString have {0} chars",myString.Length);
myString=myString.ToLower();//转小写
myString=myString.ToUpper();//转大写
myString=myString.Trim();//删前后空格
myString=myString.TrimStart();//删前空格
myString=myString.TrimEnd();//删后空格
myString=myString.PadLeft(位数);//前补空格到指定位数
myString=myString.PadRight(位数);//后补空格到指定位数
myString=myString.PadLeft(位数,字符);//前补指定字符到指定位数
char［］ trimChars = ｛"e","#","*"｝;
myString = myString.trim(trimChars);//删指定字符
四，常量：
　　　Const int intTwo =
 2 (必须声明的同时赋值)
五，运算符：按优先级顺序排列

　　算术运算符：前缀的++和-- ,前缀一元的+和- 乘 * 除 / 求余 % 加 + 减 -

　　位移运算符：<<,>>
　　比较运算符：小于 < 大于 > 小于等于 <= 大于等于 >=
　　比较运算符：==,!=
　　逻辑运算符：&
　　逻辑运算符：^
　　逻辑运算符：|
　　逻辑运算符：&&
　　逻辑运算符：||
　　比较运算符：等于 =
 *=
 /=
 %=
 +=
 -=
 <<=
 >>=
 &=
 ^=  |=

　　后缀的++和--
六，名称空间
　　using system;  //system是.net FrameWork应用程序根命名空间，之后就能在全局名称空间引用system中的代码。
　　namespace 空间名称
　　　...{
　　　　　　using 空间名称2.代码2;//之后就能在代码1处直接引用代码2
　　　　　　代码1;
　　　　　　namespace 空间名称2
　　　　　　...{
　　　　　　代码2;
　　　　　　}
　　　}
七，条件语句
　　Ａ，If语句：通用判断
　　　　If （条件1）
　　　　　　代码1;
　　　　Else
　　　　　　代码2;
　　　　If （条件1）
　　　　｛｝
　　　　Else
　　　　｛｝
　　Ｂ，Switch语句：用于同条件多结果判断
　　　　Switch (条件)
　　　　　...{
　　　　　　Case 结果1:
　　　　　　代码1;
　　　　　　break;
　　　　　　Case 结果2:
　　　　　　代码2;
　　　　　　break;
　　　　　　Case 结果3:
　　　　　　代码3;
　　　　　　goto Case  结果2;//此时Case..相当于一个Label
　　　　　　Case 结果4:
　　　　　　代码4;
　　　　　　Return;
　　　　　　Case 结果5:
　　　　　　Case 结果6:
　　　　　　Case 结果7:
　　　　　　代码567;//只要满足上面三个Case之一就执行。
　　　　　　break;
　　　　　　...
　　　　　　Default:
　　　　　　代码;
　　　　　　break;
　　　　　｝
　　Ｃ，三元运算语句：(条件)?True结果:False结果
　　　　常用于简单赋值语句：string myString = (myInteger<10)?"Less than 10":"Great than or equal to";
　　　　或者用于简单格式化文本语句：Console.WriteLine("I am {0} year{1} old.",myinteger,myinteger==1?"":"s");
八，循环语句：
　　Ａ，Do...While： 当条件为True时循环。
　　　　Do
　　　　...{...}
　　　　While(条件);//分号不可少
　　Ｂ，While...： 当条件为True 时循环。
　　　　While(条件)
　　　　...{...}　　
　　Ｃ，For...： 使用计数器循环。
　　　　For (变量;条件;操作)//可以在此时声明变量，但作用域就仅限于循环内了。
　　　　...{...
　　　　Break;//跳出整个循环
　　　　Return;
　　　　Continue;//中止当前循环,继续下一个循环
　　　　Goto 标签;//禁止从循环外部用goto跳入循环内部
　　　　}
九，函数
Ａ，函数定义：
    static 返回值类型/void 函数名(参数类型1 参数1,参数类型2 参数2,...)
    ...{
      ...
      return 返回值;//return必须在函数结束前被处理，不能跳过
      //return ;//当用于void时用不带返回值的return来中止函数。
    }
Ｂ，参数数组：
  static
  int sumVals(params
  int[] vals)
  ...{
    int sum =0;
    foreach(int val in vals)
    ...{
      sum+=val;
    }
    return sum;
  }

  static
  void Main(string[] args)
  ...{
    int sum = sumVals(1,5,2,9,8);
    Console.WriteLine("Summed Values = {0}",sum);
  }
Ｃ，值传递参数/引用传递参数/out输出参数
static
  void showDouble(ref
  int val)//引用传递参数
...{
  val*=2;
  Console.WriteLie("val doubled = {0}",val);
}
static
  void showDouble2(int val)//值传递参数
...{
  val*=2;
  Console.WriteLine("val doubled = {0}",val);
}
static
  void showDouble3(int val,out
  int valIndex)//out输出参数
...{
  val*=2;
  valIndex++;
  Console.WriteLine("val doubled = {0}",val);
}

int myNmuber = 5;
showDouble(ref myNumber);//引用传递参数,会改变myNumber值，所以要求myNumber必须不是常量或者未初始化的变量。
showDouble2(myNumber);//值传递参数,不会改变myNumber值
int valindex;//out输出参数，不用初始化，初始化了也会在函数开始执行时丢失值。
showDouble3(myNumber,out valIndex);
Ｄ，全局变量
static/const 变量名//const定义的全局变量是只读的
当全局变量与局部变量同名时，局部变量优先，要用类似class1.myString来引用全局变量。
Ｅ，Main()函数；
static
  void Main()
static
  void Main(string［］ args)//args是函数命令行参数
static
  int Main()//返回一个表示函数终止状态的int值
static
  int Main(string［］ args)//返回一个表示函数终止状态的int值
Ｆ，结构中的函数
Ｇ，同名函数的重载：同名，签名不同，系统自动识别使用哪个函数
Ｈ，委托：用于把引用存储为函数以灵活调用函数
十，面向对象基础
十一，类
1，类的定义
class 类名
...{
  //类成员
}
internal/public

sealed/abstract

十和，接口
interface IMyInterface
...{
  //接口成员
}

C#语法入门

下面开始C#之行。
在开始学习C#之前，先了解下C#语句的特点：
1. C#是区别大小。2. 每一句都以分号结束，不象VB.NET。3. 多个语句通过分号可以写在一行，不过不推荐，因为不清晰。OK，开始了。
先了解下其数据类型：
bool true或false
byte 8位无符号整数
short 16位整数
int 32位整数
long 64位整数
float 32位浮点数
double 64位浮点数
char 16位字符
string 多个16位字符
宽度窄的（即字节数少的）数据类型可以直接赋给较宽的数据类型，并会自动转换为新类型。例：
float a = 9.9f;
int b=4;
a = b;
//上述把一个整型的4转换成了浮点型.同样也可以通过强制类型转换将宽类型的缩成窄类型例： float a = 9.9f;
int b=4;
b = (int)a;
//注意必须把要转换的类型名称放在圆括号内，并放在其前面字符串与数值互换： string a = Convert.ToString(b);
float a = Convert.ToSingle(b);
同样也可以像C语言那样格式化输出：
float a=3.1415926728f;
string b=a.ToString("##.##");
变量与常量声明：
C#中允许一条语句声明同一类型的多个变量
int a,b;
但为了语句清晰推荐将多个声明写成多个语句。
有一点要注意，就是如果在声明数值型变量时没有小数部分，则自动为整数类型，有小数部分的，则自动为double类型，而不是float类型，可通过下面声明，转换为不同类型：
float a=1.2f ; long b=23L ;
对于常量声明，习惯用大写符号来表示常数，如：
const float PI = 3.1415926 ;
对于字符声明，得用单引号括起来，如：
char a = ''d'' ;
还可以这样赋值：
int a = b = c = 2;
虽然方便，但并不推荐，推荐将其拆成三个语句来写，这样结构也清晰。
(注：C#的变量名长度是任意的，可以由数字和大小写字母混合组成，但第一个必须是字母。
关于C#中的转义字符：
\n ------------------------- 换行
\r ------------------------- 回车
\t ------------------------- 制表符
\b ------------------------- 退格
\f ------------------------- 换页
\0 ------------------------- 空符号
\" ------------------------- 双引号
\'' -------------------------单引号
\\ -------------------------反斜杠

还有一个较特殊的，就是＠号，只要语句前加＠号，即表示＠号后面的包括有转义符的都按不进行转义运算。
还是先看个例子吧，因为自己也有体会，一味地看语句，很无聊 ^_^
using System;
class sample
{
static void Main(string[] args)
{
string hey="希望如我所愿";
Console.WriteLine("c#快速入门,"+hey);
}
}
很头开始分析：using 语句说明程序中要用到C#的代码库，接着是个类名，可以包括有多个类，类中的东西都必须放在大括号中，整个程序以Main函数开始。按F5可以编译执行。好，完成第一个C#程序。再来看烦燥的语法：
运算符：
算术运算符：
+ --------------------- 加
- --------------------- 减
* --------------------- 乘
/ --------------------- 除
% --------------------- 求余（即整除后的余数）
逻辑运算符：
& --------------------- 按位与
| --------------------- 按位或
^ --------------------- 按位异或
~ --------------------- 取反
>>n ------------------- 右移n位
<<n ------------------- 左移n位
递增递减运算符：
++ 或 -- 或 += 或 -= 或 *= 或/=
如i=1;i++;即等i=i+1; 其它为同样的道理，不说。
比较运算符：
> 或 < 或 == 或 != 或 >= 或<= 一看就明白，也不说。
C#的条件判断：
if(a > 0)
{
a = -1;
}
else
{
Console.WriteLine(a);
}
条件必须放在括号里.

两个条件的判断，注意括号和条件中的等号
if((a = = 0) && (b>0))
{
a = -1;
b = -1;
}
else
{
Console.WriteLine(a + b);
}
switch 用于多个可能的值，如果有一个匹配，则执行相应代码，每句之后必须有break语句中断后面语句的执行。

switch(a)
{
case 1:
Console.WriteLine("1");
break;
case 2:
Console.WriteLine("2");
break;
case 3:
Console.WriteLine("3");
break;
default:
Console.WriteLine("default");
}

while 循环：
a=1;
while (a<20)
{
a=+=a;
}
只要a<20这个条件为真，则循环加a,直到a<20

do-while 循环：
a=1;
do
{
a=+=a;
}
while(a<20);
do while循环与while循环类似，区别在于do-while循环至少执行一次a+=a;

for 循环：
int j=1;
for(int i=0;i<100;i++)
{
j++;
Console.WriteLine("i = "+i+"j = "+j);

}