Cocos2d-x 系列三之C++语言

时间：2014-05-15 02:23:54 收藏：0 阅读：440

1.面向对象
<1>直接定义类

class People {
public:
    void sayHello() {
        printf("hello c oop \n");
    }
};

    People * p = new People();
    p->sayHello();

<2>使用头文件定义

Ml.h

#ifndef ML_H_
#define ML_H_

namespace cjyn { // 命名空间

class Ml {
public:
    void sayHello();
};
}
#endif /* ML_H_ */

Ml.cpp

#include "Ml.h"
#include <iostream>
#include <stdio.h>
namespace cjyn {

void Ml::sayHello() { // 返回类型 类名::方法名
    printf("hello cpp");
}

}

main.cpp 调用

#include <iostream>
#include "Ml.h"
#include <stdio.h>
using namespace cjyn;

int main(int argc, const char* argv[]) {
    cjyn::Ml *ml = new cjyn::Ml();
    ml->sayHello();
    delete ml; // 释放对象，如同C中的free
}

补充：如果没有引入using namespace cyjn，则在申明类的时候需要使用(命名空间::类名)的方式，如果引入了命名空间，则上面的申明可以直接使用类名而不需要使用命名空间；

2.类的继承(People->Man)

People.cpp

#include "People.h"
#include <iostream>
#include <stdio.h>

void People::sayHello() {
    printf("hello cpp");
}

int People::getAge() {
    return this->age;
}

People::People(int age) {
    this->age = age;
}
People::People() {
    this->age = 12;
}

People.h

#ifndef ML_H_
#define ML_H_

class People {
private:
    int age;
public:
    People();
    People(int age);
    void sayHello();
    void setAge();
    int getAge();
};

#endif /* ML_H_ */

子类Man

Man.cpp

#include "Man.h"

Man.h

#ifndef MAN_H_
#define MAN_H_
#include "People.h"

class Man: public People { // public 表示从父类继承下来的成员变量是public的
public:
};
#endif /* MAN_H_ */

main.cpp

int main(int argc, const char* argv[]) {
    Man *m = new Man();
    m->sayHello(); //hello cpp
    delete m;
}

3.引用父类方法

<1>.构造方法

Man.h

#ifndef MAN_H_
#define MAN_H_
#include "People.h"

class Man: public People { // public 表示从父类继承下来的成员变量是public的
public:
    Man(int age);
    void sayHello();
};
#endif /* MAN_H_ */

Man.cpp

Man::Man(int age) : People(age) { // 想要执行父类的构造方法只需要在子类构造方法之后加冒号并且调用父类构造方法即可
}

<2>.其他方法调用

Man.cpp

Man::Man(int age) : People(age) {
    People::sayHello(); // @1
}

void Man::sayHello() {
    printf("man say hello cpp\n");
}

Man.h

class Man: public People { // public 表示从父类继承下来的成员变量是public的
public:
    Man(int age);
    void sayHello();
};
#endif /* MAN_H_ */

main.cpp

int main(int argc, const char* argv[]) {
    Man *m = new Man(34);
    printf("age %d \n", m->getAge());
    m->sayHello(); // 调用man的sayHello
    m->People::sayHello(); // 调用People的sayHello @2
    delete m;
}

父类普通方法的调用之需要在方法名前加(类名::方法名)，有两种调用方式@1,@2;

4.面向对象特点

<1>.虚函数、纯虚函数、纯虚类

class People {
private:
    int age;
public:
    People();
    People(int age);
    // 虚函数：定义为虚函数之后就可以在运行的时候动态加载相应的方法(相当于java中多态)；
    virtual void sayHello();
    // 纯虚函数，相当于java中的抽象方法；对应的类就是抽象类
    virtual void eat()=0;
    void setAge();
    int getAge();
};
#endif /* ML_H_ */

纯虚类就是类中所有方法都是纯虚函数，相当于java中的接口；
虚函数和纯虚函数分别由子类去重写(可重写可不重写)和实现(子类必须进行实现)；

Man.h

class Man: public People { 
public:
    Man(int age);
    virtual void sayHello();
    virtual void eat();
};
#endif /* MAN_H_ */

Man.cpp

Man::Man(int age) : People(age) { // 调用父类构造方法
}

void Man::sayHello() {
    printf("man say hello cpp\n");
}

void Man::eat(){
    printf("man eat\n");
}

5.操作符重载

class Point {
private:
    int x, y;
public:
    Point(int x, int y) {
        this->x = x;
        this->y = y;
    }

    void add(Point p) {
        this->x += p.x;
        this->y += p.y;
    }

    void operator +=(Point p) {
        add(p);
    }

    int getX() {
        return this->x;
    }
    int getY() {
        return this->y;
    }
};

实例：

int main(int argc, const char* argv[]) {
    Point p(10, 10);
    std::cout << p.getX() << "\n";
    p += Point(12, 12);
    std::cout << p.getX() << "\n";

    Point *pp = new Point(5, 5);
    (*pp) += Point(4, 4);
    std::cout << pp->getX() << "\n";
}

上述代码输出结果为:10,22,9;

<2>.操作符重载之伪函数

伪函数就是把一个类当作一个方法来调用，下面直接看例子

class Point {
public:
    void operator ()() {
        std::cout << "hello point" << "\n";
    }
};

使用(这种方式的有点在于比如把类当作一个参数传递)

int main(int argc, const char* argv[]) {
    Point p;
    p(); // 输出hello point
}

6.函数指针

C++中函数指针和C语言中函数指针其实比较类似，下面是C语言中的两种定义方法

void (*Pointer)();
typedef void (*Pointer)();

接着来看C++中函数指针的定义

class Object
{
public:
    void (Object::*sayHi)();
};

class Object;
typedef void (Object::*SayHi)();

class Object
{
public:
    SayHi sayHi;
};

通过上面的例子不难看出，都是返回类型+(指针名称定义)+(参数) ，不过在C++中，需要定义函数指针所在的类，在上面即是限定指针为Object的成员或者Object子类的成员；

下面看一个例子：编写一个类继承自Object，并且给sayHi指针赋值；

class Hello : public Object
{
public:
    Hello(){
        //sayHi = (void(Object::*)())(&Hello::helloSayHi); 将Hello本身的helloSayHi方法赋予sayHi;使用@1方式定义指针
        //sayHi = (SayHi)(&Hello::helloSayHi); 将Hello的helloSzyHi方法赋予sayHi，使用@2方式定义指针

        //(this->*sayHi)(); // 执行sayHi指针； 
    }
    void helloSayHi(){
        printf("hello say hi\n");
    }
};

再来看一个例子(延迟执行)：

class Object;
typedef void (Object::*CallaterHandler)(); // 定义一个指针，该指针所属类为Object类；

#define CH(fp) (CallaterHandler)(&fp) // 取fp的地址，强制转换为CallaterHandler；

void threadFunc(Object *obj,CallaterHandler handler,int delay){
    //    _Thrd_sleep(d); // thread sleep
    (obj->*handler)(); // 执行handler指针
}

void callater(Object *obj,CallaterHandler handler,int delay){
    std::thread t(threadFunc,obj,handler,delay);
    t.join();
}

class Object
{};

class Hello :
    public Object
{
public:
    Hello(){
        //callater(this,(CallaterHandler)(&Hello::helloSayHi),3);
        callater(this,CH(Hello::helloSayHi),3);
    }
    void helloSayHi(){
        printf("hello say hi\n");
    }
};

7.引用

先来看一个例子

class PP {
public:
    PP(int x) {
        this->x = x;
    }
    void add(PP p) {
        this->x += p.getX();
    }
    int getX() {
        return this->x;
    }
private:
    int x;
};

上面的add方法传入一个PP对象，在执行相加方法时，会对传入的对象进行内存的拷贝，事实上这样的效率不高，为了防止内存的拷贝，可以把add方法更改为
add(PP &p) // &表示取地址
当然，这样的实现完全可以直接通过指针来代替；

8.有元类

在C++中，默认没家修饰符的字段为private，但是有时候需要把特定的字段公开给某一个类，这时候就需要用到有元类；

class A {
    friend class B; // 通过这样定义，就可以在B类中访问到num
private:
    int num;
public:
    A() {
        num = 10;
    }
};

class B {
public:
    B() {
        A a;
        printf("%d", a.num);
    }
};

9.集合|容器

int main(int argc, const char* argv[]) {
    std::list<std::string> l; // 需要导入list
    l.push_back("hello");
    l.push_back("spring");
    std::list<std::string>::iterator it = l.begin();
    for (; it != l.end(); it++) {
        std::cout << *it << "\n";
    }

    map<string, string> m; // 需要导入map
    m.insert(pair<string, string>("key1", "value1"));
    m.insert(pair<string, string>("key2", "value2")); //
    m["key1"] = "value1+"; //
    cout << m.at("key1");

    return 0;
}

上面的代码输出结果为：hello spring value1+

10.字符串

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

int main(int argc, const char* argv[]) {
    string s;
    s += "hello ";
    s += "string";
    cout << s << "\n";

    stringstream ss;
    ss << "hello";
    ss << 23;
    ss << "spring" << 25;
    cout << ss.str()<<"\n";
    return 0;
}

11.文件操作

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>

using namespace std;

int main(int argc, const char* argv[]) {
//    ofstream of("data.txt");
//    of << "hello cpp \n";
//    of.close();

    ifstream inf("data.txt");

    char c;
    inf >> c;
    cout << c << "\n"; // 读取第一个字符

    stringbuf sb;
    inf >> &sb;
    cout << sb.str() << "\n"; // 读取全部字符
    return 0;
}

Cocos2d-x 系列三之C++语言,布布扣,bubuko.com