适合具备C语言基础的C++教程（一）

引言

C 语言通常被认为是一种面向过程的语言，因为其本身的特性更容易编写面向过程的代码，当然也不排除使用 C 语言编写面向过程的代码，比如 Linux 的源代码以及现在很火的国产物联网操作系统 RT-Thread，其内核的实现方式都是使用 C 语言实现的面向对象的代码。相比于 C 语言来说，C++ 更能够实现面向对象的程序设计，其具有的特性也要比 C 语言要多的多。下面假设有这样一个需求。

现要描述两个人的信息，姓名，职业，年龄，并输出。

我们首先先使用 C 语言的设计思路实现这个功能。

C语言描述

如果使用 C 语言来描述上面这个问题，大部分都会想到使用结构体来完成这个要求，写出的程序也就如下所示：

#include  struct person { char *name; int age; char *work;
}; int main(int argc, char** aggv) { struct person persons[] = { {"wenzi",24,"programer"},
        {"jiao", 22,"teacher"},
    }; char i; for (i = 0; i < 2; i++)
    { printf("name is:%s,age is:%d,work is:%s\n",persons[i].name,persons[i].age,persons[i].work);
    }
}

上述这是比较初级的写法，如果对 C 语言了解的更多一点的人在写这段程序的时候，会使用函数指针的方式将代码写的更加巧妙，代码如下所示：

#include  struct person { char *name; int age; char *work; void (*printInfo)(struct person *per);
}; void printInfo(struct person *per) { printf("The people's name is:%s,age is:%d,work is:%s\n",per->name,per->age,per->work);
} int main(int argc, char** argv) { struct person per[2]; per[0] = {"wenzi",18,"programer",printInfo};
    per[1] = {"jiaojiao",18,"teacher",printInfo};

    per[0].printInfo(&per[0]);
    per[1].printInfo(&per[1]);
}

使用了函数指针的方式来书写这个程序，程序也变得更加简介了，主函数里也少了for循环。

C++ 的引入

那除此之外，还有更好的书写方式么，这个时候就要引入 C++ 的特性了，上述代码中在执行函数时都传入了参数，那要如何做才能将上述中的参数也省略去呢，且看如下的代码：

#include  struct person { char *name; int age; char *work; void prinfInfo(void) { printf("The people's name is:%s,age is:%d,work is:%s\n",name,age,work);       
    }
}; int main(int argc, char** argv) { struct person persons[] = { {"wenzi", 18,"program"},
        {"jiao", 18, "teacher"},
    };

    persons[0].prinfInfo();
    persons[1].prinfInfo(); return 0;
}

上述代码中使用了 C++ 的特性，在结构体中定义了函数，然后也就可以直接调用函数了，跟上面 C 语言的代码相比较，它没了实参，而且代码看起来也比 C 语言更加简洁了。

实际在 C++ 中它具有自己独有的一套机制来实现上述的代码，也就是即将说明的class,有了 class 之后，我们就可以这样书写代码：

#include  class person { public: char * name; int age; char * work; void printInfo(void) { printf("The people's name is:%s,age is:%d,work is:%s\n",name,age,work); 
    }
} int main(int argc, char** argv) {
    person persons[] = {
        {"wenzi", 18,"program"},
        {"jiao", 18, "teacher"},
    };

    persons[0].prinfInfo();
    persons[1].prinfInfo(); return 0;
}

上述就是关于 C++ 的一个简单的引入过程。

C++ 数据访问控制

但是为了能够改变类里的数据，但是又要使得这个改变不要越界，避免胡乱地改变，我们可以这样来定义这个类：

#include  #include  class Person { private: char *name; int age; char *work; public: void PrintInfo(void) { cout << "name is:" << name << "age = "<< age << "work is:"<< work <<endl;
    }
};

这样定义一个类之后，类里面的数据成员就变成了私有的，不能够在外部进行访问，比如下面这样子就是错误的：

int main(int argc, char ** argv) {
    Person per;
    per.age = 10; // error }

上述这样进行数据的访问就是错误的，那么要如何进行访问呢，我们可以定义这样一个成员函数进行数据的读写，比如下面的代码所示：

#include  #include  using namespace std; class Person { private: char *name; int age; char *work; public: void PrintInfo(void) { cout << "name is:" << name << ",age = "<< age << ",work is:"<< work <<endl;
    } void setName(char *n) {
        name = n;
    } int setAge(int a) { if (a < 0 || a > 150)
        {
            age = 0; return 0;
        }
        age = a;
    }
};

这样定义了类之后，就可以访问私有成员了，比如下面这样进行：

int main(int argc, char **argv) {
    Person per;
    per.setName("wenzi");
    per.setAge(24);
    per.PrintInfo(); return 0;
}

上述代码加入了private访问控制符，通过在类里面定义成员函数的方式，能够对私有成员进行读写。

this 指针

再来看上述的代码，我们可以看到在书写setName和setAge这两个函数的时候，形参写的是char *n和int a，这样子给人的感觉就不是那么的直观，如果写成char *name和char *age呢，比如成员函数是像下面这样子编写的。

void setName(char *name) {
    name = name;
} int setAge(int age) { if (age < 0 || age > 150)
    {
         age = 0; return 0;
    }
        age = age;
}

上述代码也很容易看出问题，根据 C 语言的就近原则，name = name没有任何意义，这个时候就需要引入 this 指针。引入 this 指针之后的代码如下所示：

#include  #include  using namespace std; class Person { private: char *name; int age; char *work; public: void setName(char *name) { this->name = name;
    } int setAge(int age) { if (age < 0 || age > 150)
        { this->age = 0; return -1;
        } this->age = age; return 0;
    } void printInfo(void) { cout << "name =" << name << ", age =" << age << endl;
    }
}; int main(int argc, char **argv) {
    Person per;
    per.setName("wenzi");
    per.setAge(25);
    per.printInfo();
}

在上述代码中，引入了 this 指针，通过上述代码也可以非常清楚它的意思，就是代表当前实例化的对象，能够指向当前实例化对象的成员。

程序结构

上述代码中，成员函数是在类里面实现的，这样使得整个类看着十分的臃肿，我们可以按照如下的方式进行书写：

#include  class Person { private: char *name; int age; char *work; public: void SetName(char *name); int SetAge(int age;) void PrintInfo(void);
} void Person::SetName(char *name)
{ this->name = name;
} void Person::SetAge(int age)
{ this->age = age;
} void Person::PrintInfo(void)
{ cout << "name = " << name << "age = " << age << endl;
}

通过在类外面实现我们的成员函数，看起来要更为简洁一些，上述就是代码的实现形式。

多文件

上述代码中，我们都是将代码写在一个文件中，这样当代码量很大的时候，如果代码都是在一个文件里，那么会使得代码难以阅读，这个时候，我们就会将代码分别放在几个文件中来进行管理，比如实现上述相同的功能，我们的代码结构如下图所示：

#include  #include "person.h" int main(int argc, char **argv) {
    Person per; //per.name = "zhangsan"; per.setName("zhangsan");
    per.setAge(200);
    per.printInfo(); return 0;
}

#ifndef __PERSON_H__ #define __PERSON_H__ class Person { private: char *name; int age; char *work; public: void setName(char *name); int setAge(int age); void printInfo(void);
}; #endif 

#include  #include "person.h" void Person::setName(char *name)
{ this->name = name;
} int Person::setAge(int age)
{ if (age < 0 || age > 150)
    { this->age = 0; return -1;
    } this->age = age; return 0;
} void Person::printInfo(void)
{ printf("name = %s, age = %d, work = %s\n", name, age, work); 
}

target ... :prerequisites
command
...
...

person: main.o person.o g++ -o $@ $^ %.o : %.cpp
    g++ -c -o $@ $< clean: rm -f *.o person

#include  using namespace std; int add(int a, int b) { cout<<"add int+int"<<endl; return a+b;
} int add(int a, int b, int c) { cout<<"add int+int+int"<<endl; return a+b+c;
} double add(double a, double b) { cout<<"add double+double"<<endl; return a+b;
} double add(int a, double b) { cout<<"add int+double"<<endl; return (double)a+b;
} double add(double b, int a) { cout<<"add double+int"<<endl; return (double)a+b;
} int main(int argc, char **argv) {
    add(1, 2);
    add(1, 2, 3);
    add(1.0, 2.0);
    add(1, 2.0);
    add(1.0, 2); return 0;
}

#include  using namespace std; int main(int argc,char **argv) { int m;
    m = 10; int &n = m; int *p = &m; int *p1 = &n; cout << "n =" << n << endl; cout << "p =" << p << endl; cout << "p1 =" << p1 << endl; return 0; 

}

#include  using namespace std; int add_one(int a) {
    a = a+1; return a;
} int add_one(int *a) {
    *a = *a + 1; return *a;
} int add_one_ref(int &b) {
    b = b+1; return b;
} int main(int argc, char **argv) { int a = 99; int &c = a; cout<endl; cout<<"a = "<endl; cout<endl; cout<<"a = "<endl; cout<endl; cout<<"a = "<endl;

        c++; cout<<"a = "<endl; cout<<"c = "<endl; return 0;
}