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 spaceB
using 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浅拷贝和深拷贝
- 能满足已知对象去初始化未知对象，用默认的拷贝构造函数可以实现，浅拷贝
- 如果一个类中含有指针类型的变量，浅拷贝会出现错误 ，需要自己写拷贝构造函数。这种拷贝就是深拷贝。
#include<iostream>
#include<cstring>
using namespace std;
class String
{
char *buf; //用来存放字符串的
int length;//表示字符串的长度
public:
String() //不带参数的构造函数，创建一个空串
{
length = 0; //串长为0
buf = 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
