码迷,mamicode.com
首页 > 编程语言 > 详细

c++中的点号(.),冒号(:)和双冒号(::)运算符

时间:2015-04-07 09:58:01      阅读:309      评论:0      收藏:0      [点我收藏+]

标签:c++ 冒号运算符   c++双冒号运算符   冒号与双冒号   点号.运算符   

1.冒号(:)用法

(1)表示机构内位域的定义(即该变量占几个bit空间)

typedef struct _XXX{

             unsigned char a:4;  //char型的字符a占4位

             unsigned char c;

} XXX;

(2)构造函数后面的冒号起分割作用,是类给成员变量赋值的方法,初始化列表,更适用于成员变量的常量const型。
struct _XXX{

         _XXX() : y(0xc0) {  }

};
(3) public:和private:后面的冒号,表示后面定义的所有成员都是公有或私有的,直到下一个"public:”或"private:”出现为止。"private:"为默认处理。

(4)类名冒号后面的是用来定义类的继承

 class 派生类名 : 继承方式  基类名
{
        派生类的成员
};
继承方式:public、private和protected,默认处理是public。

2.双冒号(::)用法

(1)表示“域操作符”
        例:声明了一个类A,类A里声明了一个成员函数void f(),但没有在类的声明里给出f的定义,那么在类外定义f时, 就要写成void A::f(),表示这个f()函数是类A的成员函数
(2)直接用在全局函数前,表示是全局函数
        例:在VC里,你可以在调用API 函数里,在API函数名前加 ::
(3)表示引用成员函数及变量,作用域成员运算符
        例:System::Math::Sqrt() 相当于System.Math.Sqrt()
——————————————————————————————————————

VC中如下
      ::是C++里的“作用域分解运算符”。比如声明了一个类A,类A里声明了一个成员函数voidf(),但没有在类的声明里给出f的定义,那么在类外定义f时,就要写成voidA::f(),表示这个f()函数是类A的成员函数。
  :: 一般还有一种用法,就是直接用在全局函数前,表示是全局函数。当类的成员函数跟类外的一个全局函数同名时,考试,大提示在类内定义的时候,打此函数名默认调用的是本身的成员函数;如果要调用同名的全局函数时,就必须打上::以示区别。比如在VC里,你可以在调用API函数时,在API函数名前加::。

*********************************************************************************************

这篇文章将总结C/C++中的冒号的用法。


1、位域定义
这个在前面关于位结构体的文章里说得够多的了,不再重复了。

2、类构造函数(Constructor)的初始化列表
先说下什么叫构造函数吧(是不是啰嗦了?C++的人应该都知道了吧,还是以防万一一下)。所谓构造函数,就是与类同名的函数,它与普通函数的区别在于,它没有返回类型。
在构造函数后面紧跟着冒号加初始化列表,各初始化变量之间以逗号(,)隔开。下面举个例子。

class myClass
{
    public :
               myClass();// 构造函数,无返回类型,可以有参数列表,这里省去
               ~myClass();// 析构函数
               int a;
               const int b;
}

myClass::myClass():a(1),b(1)// 初始化列表
{
}
上面的例子展示了冒号的这个用法,下面对这个用法进行几点说明:
1)初始化列表的作用相当于在构造函数内进行相应成员变量的赋值,但两者是有差别的
在初始化列表中是对变量进行初始化,而在构造函数内是进行赋值操作。两都的差别在对于像const类型数据的操作上表现得尤为明显。我们知道,const类型的变量必须在定义时进行初始化,而不能对const型的变量进行赋值,因此const类型的成员变量只能(而且必须)在初始化列表中进行初始化,即下面的代码将会出错:
myClass::myClass()
{
     a = 1;// 没错,效果相当于在初始化列表中进行初始化
     b = 1;// 出错,const变量不能进行赋值操作;
}
2)初始化的顺序与成员变量声名的顺序相同。
     先看一下下面的程序:
myClass::myClass():b(1),a(b)
{
}
这样的执行结果a,b各是多少呢?b=1,a=1?不是,b=1而a是个随机数。这一点是相当重要的哦,一般在初始化列表中进行初始化时,初始化的顺序应与声明的顺序保持一致,防止出现不必要的错误
3)对于继承的类来说,在初始化列表中也可以进行基类的初始化,初始化的顺序是先基类初始化,然后再根据该类自己的变量的声明顺序进行初始化。

3、声明基类。
假设我们重新定义一个类,继承自myClass类。定义方式如下:
class derivedClass : public myClass
{
       // 略去
}
这里的冒号起到的就是声名基类的作用,在基类类名前面可以加public/private/protected等标签,用于标识继承的类型,也可以省略,省略的话,用class定义的类默认为private,用struct定义的类默认为public,至于具体各个标签有什么区别这里就不说了。
与初始化列表一样的,这里也可以声名多个基类,各基类之间用逗号(,)隔开。

4、条件语句(? :)
与?构成条件语句,作用相当于if else,如下;
int a,b,c;
a=3;
b=2;
c=a>b?a:b;// 如果a>b成立,则反a赋给c,否则把b赋给c
条件语句的结构为:
条件表达式?表达式1:表达式2
当条件表达式为true时,表达式的值为表达式1的值,否则为表达式2的值。
几点说明:
1)?:可以嵌套,但不推荐使用(难懂),下面的表达式你能看懂啥意思不?
int max = i>j ? i>k ? i : k : j>k ? j : k;
脑袋大了吧,呵呵。
2)?:具有很低的优先级,这个要注意哦,下面的程序执行结果是啥呢?
int i = 3;
int j = 2;
cout << i>j?i:j; // 出错<<比>具有更高的优先级,执行顺序为 ((cout<<i)>j)?i:j,相当于是比较cout<<i与j的大小,然后根据比较结果决定表达式值为i或j,这显然要出错的,cout<<i的值是cout,不能跟整型数j进行比较
cout << (i>j)?i:j; //输出1或0,相当于(cout<<(i>j))作为判决条件,来决定表达式的值为i或j,而cout<<(i>j),i>j则输出1否则0,然后再将(cout<<(i>j))作为?:的条件,如果cout正确执行则为1(true),否则为0(false),以此决定表达式值为i或j
cout <<(i>j?i:j);//i>j则输出i,否则输出j,表达式值为true如果cout正确执行,否则为false
更多的关于优先级的问题就不说了。

5、语句标签
通常跟goto配合使用,如:
step1: a = f1();
....
goto step1;
这种作法也不是很推荐,原因在于它破坏了语句的顺序执行,这样的代价大家应该清楚吧。不过存在即为合理嘛,既然它还存在,肯定还是有它的用处有它的好处的,比如说,多层嵌套的退出(会比break continue直观一点吧),也可以避免重复代码之类之类的

6、switch语句中case后。
这个不说了,要是不会的话,我也没话可说了。

7、汇编指令模板
这个我也不懂,不班门弄斧了,可以参考一下:http://developer.e800.com.cn/articles/2006/43/1144846933898_1.html
改天学习一下。

*********************************************************************************************

1、 
作用域符号::的前面一般是类名称,后面一般是该类的成员名称,C++为例避免不同的类有名称相同的成员而采用作用域的方式进行区分
如:A,B表示两个类,在A,B中都有成员member。那么
A::member就表示类A中的成员member

B::member就表示类B中的成员member


2、 

全局作用域符号:当全局变量在局部函数中与其中某个变量重名,那么就可以用::来区分如:

char zhou; //全局变量

void sleep()

{

    char zhou; //局部变量

    char(局部变量) = char(局部变量) *char(局部变量) ;

    ::char(全局变量) =::char(全局变量) *char(局部变量);

}
3、 

::是C++里的“作用域分解运算符”。比如声明了一个类A,类A里声明了一个成员函数voidf(),但没有在类的声明里给出f的定义,那么在类外定义f时,就要写成voidA::f(),表示这个f()函数是类A的成员函数。例如

	class CA {  
	public:  
	  int ca_var;  
	  int add(int a, int b);  
	  int add(int a);  
	}; 
	  
	//那么在实现这个函数时,必须这样书写:  
	int CA::add(int a, int b)  
	{  
	  return a + b;  
	}  
	  
	//另外,双冒号也常常用于在类变量内部作为当前类实例的元素进行表示,比如:  
	int CA::add(int a)  
	{  
	  return a + ::ca_var;  
	} 
	  
	//表示当前类实例中的变量ca_var。
  

C++中点号(.)运算符

首先介绍一下C++中的结构。对于一个结构来说,
struct MyStruct {
         int member_a;
};

如果有个变量MyStruct s,那么使用其中的成员元素时可以用
s.member_a = 1;

如果采用指针方法访问,比如MyStruct * ps,那么同样的访问必须用箭头号:

ps->member_a = 1;

::只用在类成员函数和类成员变量中。比如,声明一个类:

class CA {
          public:
          int ca_var;
          int add(int a, int b);
          int add(int a);
};

那么在实现这个函数时,必须这样书写:
int CA::add(int a, int b)
{
     return a + b;
}

另外,双冒号也常常用于在类变量内部作为当前类实例的元素进行表示,比如:

int CA::add(int a)
{
     return a + ::ca_var;
}

表示当前类实例中的变量ca_var。

c++中当定义类对象是指针对象时候,就需要用到->指向类中的成员;当定义一般对象时候时就需要用到"."指向类中的成员.......
例如:

class A
{
    public: 
          play();
}

如果定义如下:

A *p则:p->play()使用; 左边是结构指针。
A p 则:p.paly()使用; 左边是结构变量。


c++中的点号(.),冒号(:)和双冒号(::)运算符

标签:c++ 冒号运算符   c++双冒号运算符   冒号与双冒号   点号.运算符   

原文地址:http://blog.csdn.net/tham_/article/details/44905561

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!