c++基础/类和对象

c++基础

2.1名字空间

namespace 防止命名冲突

说明：名字空间可以在全局作用域或其他作用域（另一个名字空间）内部定义，但不能在函数或类的内部定义。

使用：

#include<iostream>
using namespace std; //std中包含关键字，cin,cout等
namespace spaceA{int x;int y;
}
int main()
{spaceA::x = 8;  //1.名字空间名称::局部内容名称cout<<spaceA::x<<endl;spaceA::y = 9;  cout<<spaceA::y<<endl;// 2.using namespace 名字空间名称using namespace spaceA;x = 8;y = 9;cout<<x<<y;// 3.using spaceBusing spaceA::x;x=4;cout<<x;return 0;
}

2.2数据类型

基本数据类型：整型，实型，字符型，布尔型，无值型

非基本数据类型：复合数据类型，构造数据类型

 2.3 new和delete

指针变量的定义：

注意：ip 是指针变量， *ip是解引用（不要和int *ip 弄混）

int num ;
int *ip = # //定义一个整型指针变量
*ip = 4;  //解引用
// 解引用操作仅适用于那些确实指向了某个对象的有效指针

 为什么指针变量在定义时要说明其类型？

        指针变量保存的是地址， 如一个整型指针变量是4个字节，要访问内存时，要将4个字节全部读出来时才有意义。

new        &       delete

        new 内存分配

        delete 释放new分配的存储空间

#include<iostream>
using namespace std;
int main(){int *p;p = new int; //申请一个整型空间*p = 7;cout<<*p<<endl;delete p;   return 0;
}

注意：定义和使用指针变量的方法

2.4引用

 2.5函数

 2.6参数传递

1.传值参数：

        当初始化一个非引用类型的变量时，初始值被拷贝给变量，此时，变量的改动不会影响初始值。

        当执行指针拷贝操作时，拷贝的是指针的值。拷贝之后，两个指针是不同的指针。

2.传引用参数

        通过使用引用形参，允许函数改变一个或多个实参的值。引用形参绑定初始化它的对象

2.7内联函数 

 调用函数一般比求等价表达式的值要慢一些。在大多数机器上，一次函数调用包含这一系类的工作: 调用前要保存寄存器，并在返回时恢复；可能需要拷贝实参；程序转换到另一个位置继续执行。

2.8重载函数

 2.9异常处理

 try & throw & catch ....

 类与对象

3.1类

类是具有相同属性和方法的一类对象集合的抽象

定义类就是对问题抽象和封装的过程。

类的定义：

 

  关键：在类体外定义成员函数

3.2对象

对象是类的实例或实体

 对象成员的访问：

point *point_p1;
point_p1 = &p1;
//定义一个指针，并且赋予指针意义，指向p1的地址
point_p1->set(1,2); //使用指针访问成员变量
p1.show();
(*point_p1).set(2,3); //使用对象访问成员
(&p1)->show()

 3.3类的界面和实现

point.h & point.cpp 分开实现

//point.cpp
#include<iostream>
#include "point.h"
using namespace std;
void point::set1(int a,int b)
{x = a;y = b;
}
void point::show()
{cout<<x<<y<<endl;
}

//point.h
class point
{
private:int x,y;
public:void set1(int a,int b);void show();
};

//main.cpp
#include<iostream>
#include "point.h"
using namespace std;
int main(){point p1;p1.set1(1,1);p1.show();return 0;
}

3.3.1构造函数

构造函数是一种特殊的成员函数，对象的创建和初始化由它来完成。

 1.构造函数不能是私有的；

2.构造函数可以重载，可以带一个参数，也可以不带参数。

3.3.2成员初始化列表

 冒号后面就是成员初始化表：可以使用引用&，

 3.3.3具有默认参数的构造函数

 3.3.4析构函数（重点）

特点：释放对象，回收空间

自动被调用

析构函数自动被调用 

 3.3.5拷贝构造函数

定义：

 特点：

 3.3.6浅拷贝和深拷贝

 

1.  能满足已知对象去初始化未知对象，用默认的拷贝构造函数可以实现，浅拷贝
2.  如果一个类中含有指针类型的变量，浅拷贝会出现错误 ，需要自己写拷贝构造函数。这种拷贝就是深拷贝。 

#include<iostream>
#include<cstring>
using namespace std;
class String
{char *buf;  //用来存放字符串的int length;//表示字符串的长度
public:String()    //不带参数的构造函数，创建一个空串{length = 0;    //串长为0buf = new char; buf[0] = '\0';//字符串的结束符}String(char *s)   //用字符串初始化{length=strlen(s);buf = new char[length+1];//开辟空间，对一个空间放'\0'字符串的结束符strcpy(buf,s);}//拷贝构造函数String(const String &s){length = s.length;//buf = s.buf; 错误的方法buf = new char[length+1];strcpy(buf,s.buf);cout<<"我是默认拷贝构造函数,深拷贝"<<endl;}~String()      //析构函数，回收空间{delete[] buf;}void show(){cout<<buf<<endl;}
};
int main()
{String s1((char *)"helloworld!"); //需要强制类型转换一下s1.show();String s2 = s1; //拷贝一下s2.show();return 0;
}

拷贝成功

 3.4this指针

用途:

①区分成员和非成员

 上面的方式是不对的，正确的赋值方式

 ② 类的方法需要返回当前对象的引用

   3.5向函数传递对象 

                                                              

3.6类的静态成员                                                        

 

 

#include<iostream>
using namespace std;
class student{public:static int count;static double total;student(double score){this->score = score;count++;total+=score;}static double getAverage(){return total/count;}private:double score;
};
int student::count = 0;
double student::total = 0;  //初始化成员int main()
{student s1(70),s2(90);cout<<s1.getAverage()<<endl;  //通过对象去访问cout<<student::getAverage()<<endl; // 通过类名访问，static 类里面的静态全局变量return 0;
}

3.7类的友元

 

//一个类的成员函数作为另一个类的友元使用
#include<iostream>
using namespace std;
class girl; //声明一下
class boy
{string name;public:boy(string nm){name = nm;}void introduce(){cout<<"i am "<<name<<endl;}void introducefriend(girl &x);  
};
class girl
{string name;public:girl(string nm){name = nm;}void introduce(){cout<<"i am"<<name<<endl;}friend void boy::introducefriend(girl &x);//声明boy的成员函数introducefriend是girl的友元函数
};
void boy::introducefriend(girl &x)
{cout<<"she is "<<x.name<<endl;
}
int main()
{boy boy1("tom");girl girl1("alice");boy1.introduce();boy1.introducefriend(girl1);return 0;
}

3.8对象成员

一个类的对象是另一个类的数据成员

A的对象a是B的数据成员。

 3.9const