Android NDK开发之旅22--C++--类 & 对象

字数 2654阅读 442

Android NDK开发之旅 目录

C++ 类 & 对象

C++ 在 C 语言的基础上增加了面向对象编程,C++ 支持面向对象程序设计。类是 C++ 的核心特性,通常被称为用户定义的类型。
类用于指定对象的形式,它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。

C++ 类定义

定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,也就是说,它定义了类的对象包括了什么,以及可以在这个对象上执行哪些操作。
类定义是以关键字 class 开头,后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如,我们使用关键字 class 定义 Box 数据类型,如下所示:

class Box
{
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};

关键字 public 确定了类成员的访问属性。在类对象作用域内,公共成员在类的外部是可访问的。您也可以指定类的成员为 private 或 protected。

定义 C++ 对象

类提供了对象的蓝图,所以基本上,对象是根据类来创建的。声明类的对象,就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象:

Box Box1;          // 声明 Box1,类型为 Box
Box Box2;          // 声明 Box2,类型为 Box

对象 Box1 和 Box2 都有它们各自的数据成员。

访问数据成员

类的对象的公共数据成员可以使用直接成员访问运算符 (.) 来访问。

示例如下:
#include <iostream>

using namespace std;

class Box
{
public:
    double length;   // 长度
    double breadth;  // 宽度
    double height;   // 高度
};

int main()
{
    Box Box1;        // 声明 Box1,类型为 Box
    Box Box2;        // 声明 Box2,类型为 Box
    double volume = 0.0;     // 用于存储体积

                             // box 1 详述
    Box1.height = 5.0;
    Box1.length = 6.0;
    Box1.breadth = 7.0;

    // box 2 详述
    Box2.height = 10.0;
    Box2.length = 12.0;
    Box2.breadth = 13.0;

    // box 1 的体积
    volume = Box1.height * Box1.length * Box1.breadth;
    cout << "Box1 的体积:" << volume << endl;

    // box 2 的体积
    volume = Box2.height * Box2.length * Box2.breadth;
    cout << "Box2 的体积:" << volume << endl;

    system("pause");
    return 0;
}

结果如下:
Box1 的体积:210
Box2 的体积:1560

类成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数,就像类定义中的其他变量一样。类成员函数是类的一个成员,它可以操作类的任意对象,可以访问对象中的所有成员。
让我们看看之前定义的类 Box,现在我们要使用成员函数来访问类的成员,而不是直接访问这些类的成员

示例如下:
#include <iostream>

using namespace std;

class Box
{
   public:
      double length;         // 长度
      double breadth;        // 宽度
      double height;         // 高度

      // 成员函数声明
      double getVolume(void);
      void setLength( double len );
      void setBreadth( double bre );
      void setHeight( double hei );
};

// 成员函数定义
double Box::getVolume(void)
{
    return length * breadth * height;
}

void Box::setLength( double len )
{
    length = len;
}

void Box::setBreadth( double bre )
{
    breadth = bre;
}

void Box::setHeight( double hei )
{
    height = hei;
}

// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1,类型为 Box
   Box Box2;                // 声明 Box2,类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);

   // box 2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);

   // box 1 的体积
   volume = Box1.getVolume();
   cout << "Box1 的体积:" << volume <<endl;

   // box 2 的体积
   volume = Box2.getVolume();
   cout << "Box2 的体积:" << volume <<endl;

   system("pause");
   return 0;
}

结果如下:
Box1 的体积: 210
Box2 的体积: 1560

C++ 类访问修饰符
数据封装是面向对象编程的一个重要特点,它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 publicprivateprotected 来指定的。关键字 publicprivateprotected称为访问修饰符。
一个类可以有多个 publicprotectedprivate标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符private

公有(public)成员

公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值。

私有(private)成员

私有成员变量或函数在类的外部是不可访问的,甚至是不可查看的。只有类和友元函数可以访问私有成员。

保护(protected)成员

保护成员变量或函数与私有成员十分相似,但有一点不同,保护成员在派生类(即子类)中是可访问的。
在下一个章节中,您将学习到派生类和继承的知识。现在您可以看到下面的实例中,我们从父类 Box 派生了一个子类 smallBox。
下面的实例与前面的实例类似,在这里 width 成员可被派生类 smallBox 的任何成员函数访问。

示例如下:
#include <iostream>
using namespace std;

class Box
{
protected:
    double width;
};

class SmallBox :Box // SmallBox 是派生类
{
public:
    void setSmallWidth(double wid);
    double getSmallWidth(void);
};

// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
    return width;
}

void SmallBox::setSmallWidth(double wid)
{
    width = wid;
}

// 程序的主函数
int main()
{
    SmallBox box;

    // 使用成员函数设置宽度
    box.setSmallWidth(5.0);
    cout << "Width of box : " << box.getSmallWidth() << endl;

    system("pause");

    return 0;
}

结果如下:

Width of box : 5

继承中的特点

public, protected,private三种继承方式,它们相应地改变了基类成员的访问属性。
1.public 继承:基类public 成员,protected 成员,private成员的访问属性在派生类中分别变成:public, protected, private
2.protected继承:基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:protected, protected, private
3.private 继承:基类public 成员,protected 成员,private成员的访问属性在派生类中分别变成:private, private, private
但无论哪种继承方式,上面两点都没有改变:
1.private 成员只能被本类成员(类内)和友元访问,不能被派生类访问;
2.protected 成员可以被派生类访问。

public 继承
示例如下:
#include<iostream>
using namespace std;

class A {
public:
    int a;
    A() {
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
    }
    void fun() {
        cout << a << endl;    //正确
        cout << a1 << endl;   //正确
        cout << a2 << endl;   //正确
        cout << a3 << endl;   //正确
    }
public:
    int a1;
protected:
    int a2;
private:
    int a3;
};
class B : public A {
public:
    int a;
    B(int i) {
        A();
        a = i;
    }
    void fun() {
        cout << a << endl;       //正确,public成员
        cout << a1 << endl;       //正确,基类的public成员,在派生类中仍是public成员。
        cout << a2 << endl;       //正确,基类的protected成员,在派生类中仍是protected可以被派生类访问。
        //cout << a3 << endl;       //错误,基类的private成员不能被派生类访问。
    }
};
int main() {
    B b(10);
    cout << b.a << endl;
    cout << b.a1 << endl;   //正确
    //cout << b.a2 << endl;   //错误,类外不能访问protected成员
    //cout << b.a3 << endl;   //错误,类外不能访问private成员
    system("pause");
    return 0;
}

结果如下:
10
1
protected 继承
示例如下:
#include<iostream>
#include<assert.h>
using namespace std;
class A{
public:
  int a;
  A(){
    a1 = 1;
    a2 = 2;
    a3 = 3;
    a = 4;
  }
  void fun(){
    cout << a << endl;    //正确
    cout << a1 << endl;   //正确
    cout << a2 << endl;   //正确
    cout << a3 << endl;   //正确
  }
public:
  int a1;
protected:
  int a2;
private:
  int a3;
};
class B : protected A{
public:
  int a;
  B(int i){
    A();
    a = i;
  }
  void fun(){
    cout << a << endl;       //正确,public成员。
    cout << a1 << endl;       //正确,基类的public成员,在派生类中变成了protected,可以被派生类访问。
    cout << a2 << endl;       //正确,基类的protected成员,在派生类中还是protected,可以被派生类访问。
    cout << a3 << endl;       //错误,基类的private成员不能被派生类访问。
  }
};
int main(){
  B b(10);
  cout << b.a << endl;       //正确。public成员
  cout << b.a1 << endl;      //错误,protected成员不能在类外访问。
  cout << b.a2 << endl;      //错误,protected成员不能在类外访问。
  cout << b.a3 << endl;      //错误,private成员不能在类外访问。
  system("pause");
  return 0;
}

结果如下:
10

private 继承
示例如下:
#include<iostream>
using namespace std;
class A {
public:
    int a;
    A() {
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
    }
    void fun() {
        cout << a << endl;    //正确
        cout << a1 << endl;   //正确
        cout << a2 << endl;   //正确
        cout << a3 << endl;   //正确
    }
public:
    int a1;
protected:
    int a2;
private:
    int a3;
};
class B : private A {
public:
    int a;
    B(int i) {
        A();
        a = i;
    }
    void fun() {
        cout << a << endl;       //正确,public成员。
        cout << a1 << endl;       //正确,基类public成员,在派生类中变成了private,可以被派生类访问。
        cout << a2 << endl;       //正确,基类的protected成员,在派生类中变成了private,可以被派生类访问。
    //  cout << a3 << endl;       //错误,基类的private成员不能被派生类访问。
    }
};
int main() {
    B b(10);
    cout << b.a << endl;       //正确。public成员
//  cout << b.a1 << endl;      //错误,private成员不能在类外访问。
//  cout << b.a2 << endl;      //错误, private成员不能在类外访问。
//  cout << b.a3 << endl;      //错误,private成员不能在类外访问。
    system("pause");
    return 0;
}
结果如下:

10

类构造函数

类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。
构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量设置初始值。

无参构造函数
示例如下:
#include <iostream>

using namespace std;

class Line
{
public:
    void setLength(double len);
    double getLength(void);
    Line();  // 这是构造函数

private:
    double length;
};

// 成员函数定义,包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}

void Line::setLength(double len)
{
    length = len;
}

double Line::getLength(void)
{
    return length;
}
// 程序的主函数
int main()
{
    Line line;

    // 设置长度
    line.setLength(6.0);
    cout << "Length of line : " << line.getLength() << endl;

    system("pause");
    return 0;
}

结果如下:
Object is being created
Length of line : 6
有参构造函数
示例如下:
#include <iostream>
using namespace std;
//构造函数、析构函数、拷贝构造函数
class Teacher {
public:
    char *name;
    int age;
public:
    //无参构造函数
    Teacher() {
        cout << "无参构造函数" << endl;
    }
    //有参构造函数会覆盖默认的无参构造函数
    Teacher(char * name, int age) {
        this->name = name;
        this->age = age;
        cout << "有参构造函数" << endl;
    }
};

void main() {
    Teacher t1;
    Teacher t2("Rose", 20);
    cout << "Teacher name : " << t2.name << endl;
    cout << "Teacher age: " << t2.age << endl;
    //另外一种调用方式
    Teacher t3 = Teacher("jack", 21);
    cout << "Teacher name : " << t3.name << endl;
    cout << "Teacher age: " << t3.age << endl;
    system("pause");
}

结果如下:

无参构造函数
有参构造函数
Teacher name : Rose
Teacher age: 20
有参构造函数
Teacher name : jack
Teacher age: 21

类的析构函数

类的析构函数是类的一种特殊的成员函数,它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号 ~ 作为前缀,它不会返回任何值,也不能带有任何参数。析构函数有助于在跳出程序(比如关闭文件、释放内存等)前释放资源。

示例如下:
#include <iostream>
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
//构造函数、析构函数、拷贝构造函数
class Teacher {
public:
    char *name;
    int age;
public:
    //无参构造函数赋值默认值
    Teacher() {
        this->name = (char*)malloc(100);
        strcpy(name, "jack walson");
        age = 20;
        cout << "Object is being created" << endl;
        
    }
    //析构函数
    //当对象被系统释放时,析构函数被调用
    //作用:善后处理
    ~Teacher() {
        cout << "Object is being deleted" << endl;
        //释放内存
        free(this->name);
    }

};

void func() {
    Teacher t1;
    cout << "Teacher name : " << t1.name << endl;
    cout << "Teacher age : " << t1.age << endl;
}

void main() {
    func();
    system("pause");
}

结果如下:

Object is being created
Teacher name : jack walson
Teacher age : 20
Object is being deleted

类拷贝构造函数

拷贝构造函数是一种特殊的构造函数,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于:

  • 通过使用另一个同类型的对象来初始化新创建的对象。
  • 复制对象把它作为参数传递给函数。
  • 复制对象,并从函数返回这个对象。
浅拷贝
示例如下:
//浅拷贝(值拷贝)
#include <iostream>
using namespace std;
//构造函数、析构函数、拷贝构造函数
class Teacher {
private:
    char *name;
    int age;
public:
    //无参构造函数赋值默认值
    Teacher(char * name, int age) {
        this->name = (char*)malloc(100);
        strcpy(this->name, name);
        this->age = age;
        cout << "Object is being created" << endl;
    }
    //拷贝构造函数(值拷贝)
    //默认拷贝构造函数,就是值拷贝
    ~Teacher() {
        cout << "Object is being deleted" << endl;
        //释放内存
        free(this->name);
    }
    void myprintf() {
        cout << name << "," << age << endl;
    }

};

void func() {
    Teacher t1("Jack", 20);
    Teacher t2 = t1;
    t2.myprintf();   // 错误 由于t1析构函数释放内存,t2执行myprintf 为空指针异常
}

void main() {
    func();

    system("pause");

}

深拷贝
示例如下:
//深拷贝
#include <iostream>
using namespace std;

class Teacher {

public:
    char *name;
    int age;
public:
    Teacher(char *name, int age) {
        int len = strlen(name);
        this->name = (char*)malloc(len+1);
        strcpy(this->name, name);
        this->age = age;
        cout << "Object is being created" << endl;

    }

    ~Teacher() {
        cout << "Object is being deleted" << endl;
        //释放内存
        free(this->name);
    }
    Teacher(const Teacher &obj) {
        //复制name属性
        int len = strlen(obj.name);
        this->name = (char*)malloc(len+1);
        strcpy(this->name, obj.name);
        this->age = obj.age;

    }
    void myprint() {
        cout << "Teacher name : " << name << endl;
        cout << "Teacher age : " << age << endl;
    }
};

void func() {
    Teacher t1("Jack", 20);

    Teacher t2 = t1;
    //由于t1析构函数释放内存,t2执行myprintf 为空指针异常
    t2.myprint(); 
}

void main() {
    func();

    system("pause");

}
结果如下:
Object is being created
Teacher name : Jack
Teacher age : 20
Object is being deleted
Object is being deleted
结论:
浅拷贝(值拷贝),拷贝的是指针的地址
深拷贝,拷贝的是指针指向的数据内容

友元(友元函数、友元类和友元成员函数)

类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。
友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。
如果要声明函数为一个类的友元,需要在类定义中该函数原型前使用关键字 friend

友元函数

友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。类授予它的友元特别的访问权,这样该友元函数就能访问到类中的所有成员

示例如下:
#include<iostream>
using namespace std;
//友元函数
class A {

private:
    int i;
public:
    A(int i) {
        this->i = i;
    }
    void myprint() {
        cout << i << endl;
    }
    //友元函数
    friend void modify_i(A*p, int a);
};

//友元函数的实现,在友元函数中可以访问私有的属性
void modify_i(A*p, int a) {
    p->i = a;
}

void main() {
    A* a = new A(10);
    a->myprint();

    modify_i(a,20);
    a->myprint();
    system("pause");
}
结果如下:
10
20
友元类

 友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。

关于友元类的注意事项:

(1) 友元关系不能被继承。
(2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
(3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明。

示例如下:
#include<iostream>
using namespace std;

//友元类
class A {
    friend class B;
private:
    int i;
public:
    A(int i) {
        this -> i = i;
    }

    void myprintf() {
        cout << i << endl;
    }

};

//Java中Class cls = Class.forName("com.test.teacher");
//cls.setAccessable(true);  cls相当于com.test.teacher的友元类
class B {
public:
    //B这个友元类可以访问A类的任何成员
    void accessAny(A &a) {
        a.i = 30;
    }

};


void main() {
    A a(3) ;
    B b;
    b.accessAny(a);
    a.myprintf();
    system("pause");
}

结果如下:
30
友元成员函数

  使类B中的成员函数成为类A的友元函数,这样类B的该成员函数就可以访问类A的所有成员了。
  当用到友元成员函数时,需注意友元声明和友元定义之间的相互依赖,在该例子中,类B必须先定义,否则类A就不能将一个B的函数指定为友元。然而,只有在定义了类A之后,才能定义类B的该成员函数。更一般的讲,必须先定义包含成员函数的类,才能将成员函数设为友元。另一方面,不必预先声明类和非成员函数来将它们设为友元。

示例如下:
#include <iostream>

using namespace std;

class A;    //当用到友元成员函数时,需注意友元声明与友元定义之间的互相依赖。这是类A的声明
class B
{
public:
    void set_show(int x, A &a);             //该函数是类A的友元函数
};

class A
{
public:
    friend void B::set_show(int x, A &a);   //该函数是友元成员函数的声明
private:
    int data;
    void show() { cout << data << endl; }
};

void B::set_show(int x, A &a)       //只有在定义类A后才能定义该函数,毕竟,它被设为友元是为了访问类A的成员
{
    a.data = x;
    cout << a.data << endl;
}

int main(void)
{
    class A a;
    class B b;

    b.set_show(1, a);

    system("pause");
    return 0;
}

结果如下:
1

类的静态成员

我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时,这意味着无论创建多少个类的对象,静态成员都只有一个副本。
静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句,在创建第一个对象时,所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中,但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化

示例如下:
//static 静态关键字
#include<iostream>
using namespace std;

//构造函数属性初始化列表
class Teacher {
public:
    char* name;
    //计数器
    static int total;
public:
    Teacher(char* name) {
        this->name = name;
        cout << "Teacher is being created" << endl;
    }

    char* setName(char* name) {
        return this->name;
    }

    char* getName() {
        return this->name;
    }
    ~Teacher() {
        cout << "Teacher is being deleted" << endl;
    }

    //静态方法不能调用非静态方法和属性
    static void count() {
        total++;
        cout << "count:" << Teacher::total << endl;
        //cout << this.getName << endl;  报错静态变量不能调用非静态方法
    }
    //非静态方法可以调用静态方法和属性
    void printf() {
        cout << "count:" << Teacher::total << endl;
    }

};

//静态属性初始化赋值
int Teacher::total = 9;

void main() {
    Teacher::total++;
    cout << "total:"<< Teacher::total << endl;
    //直接通过类名访问
    Teacher::count();
    //也可以通过对象名访问
    Teacher t1("John");
    t1.count();
    system("pause");
}

结果如下:
total:10
count:11
Teacher is being created
count:12

静态成员函数与普通成员函数的区别:

  • 静态成员函数没有 this 指针,只能访问静态成员(包括静态成员变量和静态成员函数)。
  • 普通成员函数有 this 指针,可以访问类中的任意成员;而静态成员函数没有 this 指针。

特别感谢:
菜鸟C++ 教程






微信号kpioneer

推荐阅读更多精彩内容