通过XML设置屏幕方向(android:screenOrientation)

1、拷贝构造函数(深拷贝和浅拷贝)

拷贝构造函数的形式

复制代码代码如下:

Class A
{
public:
  A();
  A(const A&);//拷贝构造函数
}
拷贝构造参数是引用类型其原因如下:当一个对象以传递值的方式传一个函数的时候,拷贝构造函数自动被调用来生成函数中的对象(符合拷贝构造函数调用的情况)。如果一个对象是被传入自己的拷贝构造函数,它的拷贝构造函数将会被调用来拷贝这个对象,这样复制才可以传入它自己的拷贝构造函数,这会导致无限循环直至栈溢出。

拷贝构造函数调用的三种形式:
1.一个对象作为函数参数,以值传递的方式传入函数体;
2.一个对象作为函数返回值,以值传递的方式从函数返回;
3.一个对象用于给另外一个对象进行初始化(常称为复制初始化)。
总结:当某对象是按值传递时(无论是作为函数参数,还是作为函数返回值),编译器都会先建立一个此对象的临时拷贝,而在建立该临时拷贝时就会调用类的拷贝构造函数。

深拷贝和浅拷贝
如果在类中没有显式地声明一个拷贝构造函数,那么,编译器将会自动生成一个默认的拷贝构造函数,该构造函数完成对象之间的浅拷贝。自定义拷贝构造函数是一种良好的编程风格,它可以阻止编译器形成默认的拷贝构造函数,提高源码效率。
在某些状况下,类内成员变量需要动态开辟堆内存,如果实行浅拷贝,也就是把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。事实上这就要用到深拷贝了,要自定义拷贝构造函数。
深拷贝和浅拷贝可以简单理解为:如果一个类拥有资源,当这个类的对象发生复制过程的时候,资源重新分配,这个过程就是深拷贝,反之,没有重新分配资源,就是浅拷贝。

深拷贝例子:

#include <iostream>
using namespace std;
class A{
public:
  A(int b,char* cstr){
    a=b;
     str=new char[b];
    strcpy(str,cstr);
  }
  A(const A& C){
    a=C.a;
    str=new char[a]; //深拷贝
    if(str!=0)
     strcpy(str,C.str);
  }
  void Show()  {
    cout<<str<<endl;
  }
  ~A()
  {
    delete str;
  }
 private:
   int a;
   char *str;
};
int main()
{
  A A(10,"Hello!");
  A B=A;
  B.Show();
  return 0;
}


2、C++中的类成员声明static

  在类中声明static变量或者函数时,初始化时使用作用域运算符来标明它所属类,因此,静态数据成员是类的成员,而不是对象的成员,这样就出现以下作用:

(1)类的静态成员函数属于整个类而非类的对象,所以它没有this指针,这就导致 了它仅能访问类的静态数据和静态成员函数     

(2)不能将静态成员函数定义为虚函数。      

(3)由于静态成员声明于类中,操作于其外,所以对其取地址操作,就多少有些特殊 ,变量地址是指向其数据类型的指针 ,函数地址类型是一个“nonmember函数指针”。

(4)由于静态成员函数没有this指针,所以就差不多等同于nonmember函数,结果就 产生了一个意想不到的好处:成为一个callback函数,使得我们得以将C++和C-based X W indow系统结合,同时也成功的应用于线程函数身上。  

(5)static并没有增加程序的时空开销,相反她还缩短了子类对父类静态成员的访问 时间,节省了子类的内存空间。      

(6)静态数据成员在<定义或说明>时前面加关键字static。      

(7)静态数据成员是静态存储的,所以必须对它进行初始化 (程序员手动初始化,否则编译时一般不会报错,但是在Link时会报错误)     

(8)静态成员初始化与一般数据成员初始化不同:

初始化在类体外进行,而前面不加static,以免与一般静态变量或对象相混淆;
初始化时不加该成员的访问权限控制符private,public等;        
初始化时使用作用域运算符来标明它所属类;
           所以我们得出静态数据成员初始化的格式:
<数据类型><类名>::<静态数据成员名>=<值>

(9)为了防止父类的影响,可以在子类定义一个与父类相同的静态变量,以屏蔽父类的影响。这里有一点需要注意:我们说静态成员为父类和子类共享,但我们有重复定义了静态成员,这会不会引起错误呢?不会,我们的编译器采用了一种绝妙的手法:name-mangling 用以生成唯一的标志

1、静态数据成员

#include <iostream.h> 
class Myclass { 
public: 
    Myclass(int a,int b,int c); 
    void GetSum(); 
private: 
    int a,b,c; 
    static int Sum;//声明静态数据成员 
}; 
int Myclass::Sum=0;//定义并初始化静态数据成员 

Myclass::Myclass(int a,int b,int c) 
{ 
    this->a=a; 
    this->b=b; 
    this->c=c; 
    Sum+=a+b+c; 
} 

void Myclass::GetSum() 
{ 
    cout < <"Sum=" < <Sum < <endl; 
} 

void main() 
{ 
    Myclass M(1,2,3); 
    M.GetSum(); 
    Myclass N(4,5,6); 
    N.GetSum(); 
    M.GetSum(); 

}

   2、静态成员函数 

#include <iostream.h> 
class Myclass { 
    public: 
    Myclass(int a,int b,int c); 
    static void GetSum();/声明静态成员函数 
private: 
    int a,b,c; 
    static int Sum;//声明静态数据成员 
}; 
int Myclass::Sum=0;//定义并初始化静态数据成员 

Myclass::Myclass(int a,int b,int c) 
{ 
    this->a=a; 
    this->b=b; 
    this->c=c; 
    Sum+=a+b+c; //非静态成员函数可以访问静态数据成员 
} 

void Myclass::GetSum() //静态成员函数的实现 
{ 
    // cout < <a < <endl; //错误代码,a是非静态数据成员 静态成员函数由于不是与任何的对象相联系,因此它不具有this指针。从这个意义上讲,它无法访问属于类对象的非静态数据成员,也无法访问非静态成员函数,它只能调用其余的静态成员函数。
    cout < <"Sum=" < <Sum < <endl; 
} 

void main() 
{ 
    Myclass M(1,2,3); 
    M.GetSum(); 
    Myclass N(4,5,6); 
    N.GetSum(); 
    Myclass::GetSum(); 
} 

3、Const关键字修饰变量、成员函数

3.1.用const 修饰函数的参数

如果参数作输出用,不论它是什么数据类型,也不论它采用“指针传递”还是“引用传递”,都不能加const 修饰,否则该参数将失去输出功能。const 只能修饰输入参数:

如果输入参数采用“指针传递”,那么加const 修饰可以防止意外地改动该指针,起到保护作用。

例如StringCopy 函数:

void StringCopy(char *strDestination, const char *strSource);

其中strSource 是输入参数strDestination 是输出参数。给strSource 加上const修饰后,如果函数体内的语句试图改动strSource 的内容,编译器将指出错误。

如果输入参数采用“值传递”,由于函数将自动产生临时变量用于复制该参数,该输入参数本来就无需保护,所以不要加const 修饰。

例如不要将函数void Func1(int x) 写成void Func1(const int x)。同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。

对于非内部数据类型的参数而言,象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a,而临时对象的构造、复制、析构过程都将消耗时间。

为了提高效率,可以将函数声明改为void Func(A &a),因为“引用传递”仅借用一下参数的别名而已,不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点:

“引用传递”有可能改变参数a,这是我们不期望的。解决这个问题很容易,加const修饰即可,因此函数最终成为void Func(const A &a)。

对于非内部数据类型的输入参数,应该将“值传递”的方式改为“const 引用传递”,目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)

对于内部数据类型的输入参数,不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的,又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)

3.2 .用const 修饰函数的返回值
如果给以“指针传递”方式的函数返回值加const 修饰,那么函数返回值(即指针)的内容不能被修改,该返回值只能被赋给加const 修饰的同类型指针。例如函数
const char * GetString(void);
如下语句将出现编译错误:
char *str = GetString();
正确的用法是
const char *str = GetString();
如果函数返回值采用“值传递方式”,由于函数会把返回值复制到外部临时的存储单元中,加const 修饰没有任何价值
例如不要把函数int GetInt(void) 写成const int GetInt(void)。
同理不要把函数A GetA(void) 写成const A GetA(void),其中A 为用户自定义的数据类型。
如果返回值不是内部数据类型,将函数A GetA(void) 改写为const A & GetA(void)的确能提高效率。但此时千万千万要小心,一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了,否则程序会出错。
函数返回值采用“引用传递”的场合并不多,这种方式一般只出现在类的赋值函数中,目的是为了实现链式表达。

例如:
class A
{
A & operate = (const A &other); // 赋值函数
};
A a, b, c; // a, b, c 为A 的对象

a = b = c; // 正常的链式赋值
(a = b) = c; // 不正常的链式赋值,但合法

如果将赋值函数的返回值加const 修饰,那么该返回值的内容不允许被改动。上例中,语句 a = b = c 仍然正确,但是语句 (a = b) = c 则是非法的。

3.3. const 成员函数
任何不会修改数据成员(即函数中的变量)的函数都应该声明为const 类型。如果在编写const 成员函数时,不慎修改了数据成员,或者调用了其它非const 成员函数,编译器将指出错误,这无疑会提高程序的健壮性。以下程序中,类stack 的成员函数GetCount 仅用于计数,从逻辑上讲GetCount 应当为const 函数。编译器将指出GetCount 函数中的错误。

class Stack
{
public:
	void Push(int elem);
	int Pop(void);
	int GetCount(void) const; // const 成员函数
private:
	int m_num;
	int m_data[100];
};
int Stack::GetCount(void) const
{
++ m_num; // 编译错误,企图修改数据成员m_num
Pop(); // 编译错误,企图调用非const 函数
return m_num;
}
const 成员函数的声明看起来怪怪的:const 关键字只能放在函数声明的尾部,大概是因为其它地方都已经被占用了。
关于Const函数的几点规则:
a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
d. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的。

4.C++引用详解

    4.1、引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似,只是用&代替了*。

  例如: Point pt1(10,10);

  Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义,pt1和pt2表示同一对象,具有相同的地址。

  需要特别强调的是引用并不产生对象的副本,仅仅是对象的同义词。因此,当下面的语句执行后:

  pt1.offset(2,2);

  pt1和pt2都具有(12,12)的值。

  引用必须在定义时马上被初始化,因为它必须是某个东西的同义词。你不能先定义一个引用后才初始化它。例如下面语句是非法的:

  Point &pt3;

  pt3=pt1;

    4.2、引用参数

  1、传递可变参数

  传统的c中,函数在调用时参数是通过值来传递的,这就是说函数的参数不具备返回值的能力。

  所以在传统的c中,如果需要函数的参数具有返回值的能力,往往是通过指针来实现的。比如,实现

  两整数变量值交换的c程序如下:

  void swapint(int *a,int *b)

  {

  int temp;

  temp=*a;

  *a=*b;

  *b=temp;

  }

  使用引用机制后,以上程序的c++版本为:

  void swapint(int &a,int &b)

  {

  int temp;

  temp=a;

  a=b;

  b=temp;

  }

  调用该函数的c++方法为:swapint(x,y); c++自动把x,y的地址作为参数传递给swapint函数。

  2、给函数传递大型对象

  当大型对象被传递给函数时,使用引用参数可使参数传递效率得到提高,因为引用并不产生对象的副本,也就是参数传递时,对象无须复制。

    4.3、引用返回值

  如果一个函数返回了引用,那么该函数的调用也可以被赋值。这里有一函数,它拥有两个引用参数并返回一个双精度数的引用:

  double &max(double &d1,double &d2)

  {

  return d1>d2?d1:d2;

  }

  由于max()函数返回一个对双精度数的引用,那么我们就可以用max() 来对其中较大的双精度数加1:

  max(x,y)+=1.0;

   4.5、常引用

  常引用声明方式:const 类型标识符 &引用名=目标变量名;

  用这种方式声明的引用,不能通过引用对目标变量的值进行修改,从而使引用的目标成为const,达到了引用的安全性。

int a ;
const int &ra=a;
ra=1; //错误
a=1; //正确

  这不光是让代码更健壮,也有些其它方面的需要。

  假设有如下函数声明:

string foo( );
void bar(string & s);

  那么下面的表达式将是非法的:

bar(foo( ));
bar(‘hello world‘);

  原因在于foo( )和‘hello world‘串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。

    引用型参数应该在能被定义为const的情况下,尽量定义为const 。    

    4.6、引用和指针的混用

    在堆中创建一块内存区域,必须要用指针指向它,否则该区域空间无法访问,当然我们可以用引用来引用指向内存空间的指针,如:

        int *p = new int;

int &r = *p;

    这样r就成了指针p读取到的值的别名,我们可以将4赋给*p的别名:

        r = 4;                                                                           

cout << *p; //值为4

    但是,我们不能直接引用来指向堆中新建空间,因为这个引用只是别名,它不可以作为指针使用,如:

int &r = new int; //这样是错误的。

    它会提示不能将指针转化为引用,因此需要加上星号(*),如:

int *&r = new int; //正确

    其意思是创建一个对空间,定义&r作为该空间的引用,这样r就成了该空间的别名。

                                                                         




通过XML设置屏幕方向(android:screenOrientation),布布扣,bubuko.com

通过XML设置屏幕方向(android:screenOrientation)

上一篇:Android 使用开源库StickyGridHeaders来实现带sections和headers的GridView显示本地图片效果


下一篇:android4.3 截屏功能的尝试与失败分析