开始学习C++

开始学习C++

C++头文件

• 可以使用传统的c的头文件
• 也可以使用C++头文件
• hpp头文件

命名空间

C++引入了新的概念，命名空间可以有效的避免大型项目中的各种名字的冲突

如果定义成没有名字的命名空间，则该命名空间下的函数只能在该命名空间下使用，不能在外面使用。

namespace {
    void func(){
        ……
    }
}

静态函数只能在文件内部使用。

class关键字 class是C++的核心，是面向对象编程的核心内容。

C++的函数必须要有严格的参数与返回值，返回值不可以不存在。

tese(){
    ……
}

volatile关键字：关键字volatile关键字在描述变量时使用，阻止编译器优化那些volatile修饰的变量，volatile被用在一些变量能被意外方式改变的地方，例如：抛出中断，这些变量若无volatile可能会和编译器的优化相冲突。

volatile int i=0;
i+=6;
i+=7;

//如果没有volatile关键字的话，将会被编译器优化成i+=13。

更严格的类型转化

在C++，不同类型的指针是不能直接赋值的，必须强转。

void *p;
int *i=p; //C

void *p;
void *i=(void *)p;  //C++

new和delete

new和delete是C++内建操作符，不需要任何头文件，用new分配的内存必须调用delete释放，不要用free。

//C的malloc在<stdlib.h>中
int *p=(int *)malloc(sizeof(int));
*p=10;
printf("%d\n",*p);
free(p);

int *p=new int;
*p=10;
cout<<*p<<endl;
delete p;

new创建数组的方法是new[];
delete删除数组的方法是delete[] p;

int *p=NULL;
delete p; //C++可以删除一个空指针

内联函数

inline关键字的意思是：内联函数不做为函数调用，而是直接吧内联函数的代码嵌入到调用语句中。

内联函数适合函数代码很少，并且频繁的大量调用的函数。

C++编译器会对inline关键字声明的函数做判断的。

引用

引用就是变量的别名，不是变量的地址

引用函数的参数，没有出栈与入栈操作，所以效率更高。

函数的缺省参数

C++允许函数在定义的时候，提供缺省参数，如果调用的时候没有提供形参，那么形参的值就是缺省值。

//这种方式是允许的
void func(int a,int b=10){
}
//这种方式是不允许的
void func(int a=10,int b){
}

函数的重载

函数的名字相同，但是函数的参数不相同。

函数参数相同，但是返回值不同，不可以重载。

重载不可以出现默认参数的

void func(int a=10){
    printf("a=%d",a);
}
void func(){
    printf("null",a);
}
//这样的话，编译器不知道选择哪一个

类

如果类函数的返回的是成员变量的指针，为了避免在类外部成员变量的值被修改，所以函数就应该返回常量指针。

class man
{
private:
    char name[100];
    int age;
public:
    void set_name(const char *s){
        memset(name,0,sizeof(name));
        if(strcmp(s,"tom")==0){
            return;
        }else{
            strcpy(name,s);
        }
    }

    const char* get_name(){ //返回常量指针
        return name;
    }

    man() {}
};
int main(int argc, char *argv[])
{
  man m;
  m.set_name("tom");
  char *p=(char *)m.get_name();//但是可以通过强转同样可以改变值
  strcpy(p,"tom");
  cout<<m.get_name()<<endl;
  return 0;
}

如果一个类成员变量和一个全局变量重名，那么在类成员函数当中默认访问的是类的成员变量。

在类的类部访问全局的标识，关键字::

C++类的本质

类其实就是结构的数据成员加可执行代码，统一提供封装，继承，多态

在类的内部，没有权限限定符，默认是private
在结构内部，没有权限限定符，默认是public

类的作用域

类成员变量作用域局限于类内部，类的外部是不可见的。

类的构造函数和析构函数

构造函数名称和类的名称一致，而且没有返回值

一个类实例化为一个对象的时候，自动调用。

man m; //在栈当中将man这个类实例化为一个对象叫m

一个对象在销毁的时候会自动调用析构函数。

一个类一定会有构造和析构函数。

构造函数通常用来初始化类的成员变量。

初始化成员列表

如果类的成员变量是const修饰的话，只能用初始化成员列表的方式来赋值

引用必须用初始化成员列表赋初值

class man
{
private:
char name[100];
const int age;
public:
}

---

man::man():age(0) { //初始化成员列表
cout<<"man"<<endl;
//    memset(name,0, sizeof(name));
//    age=0;
}

由于析构函数只有一个，所以在不同的析构函数里面给函数的成员指针分配内存的时候，一定要统一new或者new[]

 class man
{
private:
    char *name;
    int age;
public:

---

man::man(const char * s) {
    name=new char[100];
    strcpy(name,s);
    cout<<name<<endl;
}
man::man(int i) {
    name=new char[100];
    age=i;
}

man::~man() {
    delete []name;
    cout<<"~man"<<endl;
}

拷贝构造函数

浅拷贝

两个变量之间成员变量简单的赋值，默认的都是浅拷贝，两个对象指向同一块内存空间。

深拷贝

不同的对象指针成员指向不同的内存地址，拷贝构造的时候不是简单的指针赋值，而是将内存拷贝过来。

原则：如果类成员有指针，那么需要自己实现拷贝构造函数，不然存在浅拷贝的风险（一个对象修改了值的话，另外一个也会改变，或者一个释放的话，另外一个也就没了）

class man
{
public:
    char *name;
    int age;
public:
man(man &it);
}

---

man::man(man &it) {
    name=new char[100];
    strcpy(name,it.get_name());
    age=it.get_age();
}

常量类成员，常量对象

类成员后面跟关键字const 意思是告诉编译器，这个函数内部不会对类成员变量做任何修改。

class man{
    public:
        const char* get_name() const;
}

const char* get_name() const{
    return name;
}

函数的参数如果是一个类，那么就用类的引用。如果不想参数被调用函数内部修改，那么就采用const &。

void test(const man &m){
    cout<<m.get_name()<<endl;
    m.set_name("AAAA");//如果不想修改类的值的话，传参的时候用的const &则修改的时候会报错。
}

int main(){
    man m1("tom",100);
    test(m1);
}

explicit关键字

告诉C++编译器，要明确的调用这个构造函数，而不要自作聪明的认为=操作符是要调用构造的。

this指针

this就是指向自己的指针

man::man(man *this,int age){
    this->age=age;
}

类的static成员变量

static变量是放到静态内存区的，程序加载就存在，一直到程序退出才清理。

class man{
    public:
        static int count;//定义一个类的静态成员变量。
}

int man::count=0;//类静态成员变量初始化的方式。

类的static成员和类的对象没有直接关系，类的静态成员是放到静态内存区的，程序开始执行就存在，一直到程序结束才清理。

类的静态成员变量不论类的实例有多少份，但成员变量只有一份。

类的静态函数内部不能直接访问类的动态成员变量。