C++快速入门

• 编写简单的C++程序
• 输入和输出

标准输入对象
标准输出对象

• 控制结构

while 语句
for 语句
if 语句

• 类的简介
• c++程序示例：销售图书

一、
demo.cpp

int main()
{
	return 0;
}

输入和输出.cpp

#include<iostream>//cout

int main()
{
	std::cout << "Hello,world!"<<std::endl<< std::endl;//::作用域操作符  std::endl换行

	int v1;
     v1=12;
	std::cout << v1 << std::endl;

	int v2;
	std::cin >> v2;
	std::cout << v2 << std::endl;

	int a1, a2;
	//std::cin >> a1;
	//std::cin >> a2;
	std::cin >> a1 >> a2;//可以连续输入

	std::cout << a1 << "," << a2 << std::endl;
	std::cout << "The sum of" << a1
		<<"and"<<a2<<"is"<<a1 + a2 << std::endl;
  	return 0;
}

二、类
类的头文件 一般写在头文件.h中
销售单

销售 sales
项目 item
class Sales_item
{
};

Sales_item.h头文件（不完整 需要完善 否则后面的cpp运行报错）

#pragma once
#include<iostream>
using namespace std;//包含string

class Sales_item
{
public:
inline 
double Sales_item::avg_price() const
{
	if (units_sold)
		return revenue / units.sold;
	else
		return 0;
}
	//
};

销售书籍.cpp

#include<iostream>
#include"Sales_item.h"
using namespace std;

int main()
{
	Sales_item book;

	std::cout << "请输入销售的第一本书的信息：" << std::endl;

	cin >> book;

	std::cout << "您输入的信息是：" << endl;
	cout << book << endl;

	return 0;
}

item.cpp

#include<iostream>
#include"Sales_item.h"
using namespace std;

int main()
{
	Sales_item item1, item2;//item1, item2是对象
	cin >> item1 >> item2;
	cout << item1 + item2<<endl;//2个对象加起来
	return 0;
}

while

#include<iostream>

int main()
{
	int sum=0,val=1;
	while (val <= 10)
	{
		sum += val;
		++val;
	}
	std::cout << "Sum of 1 to 10 inclusive is " << sum << std::endl;
	return 0;
}

for.cpp

#include<iostream>

int main()
{
	int sum = 0;
	for (int val = 1;val <= 10;++val)
		sum += val;
	std::cout << "（for语句）Sum of 1 to 10 inclusive is"
		<< sum << std::endl;
	return 0;
}

sum小技巧.cpp

#include<iostream>

int main()
{
	int sum = 0, value;
	//当有输入时数继续循环，没有输入时停止循环
	while (std::cin >> value)
		sum += value;
	std::cout << "Sum is：" << sum << std::endl;
	return 0;
}

• vs2019 右侧的解决方案资源管理器 界面找回
  调试–>最后一个调试属性——>选定内容没有属性内容就正常（要是出现很多选项，就选择 常规）
• C++项目中经常会定义如下形式的字符串char *testString = “This is test string…”;

这样一直用的没有问题, 但今天突然编译报错了~!报错:“const char *” 类型的实参与 "char " 类型的形参不兼容之类的错误, 函数形参为char的类型直接写入字符串也会报错, 这可就郁闷了, 上网查找竟然没有找到解决方法, 但是在另一个电脑同一个项目就不会报错, 都是VS2017, 一个WIN10家庭版一个WIN10专业版, 这种错误竟然丝毫没有头绪, 中间过程也不废话了, 最后的解决办法其实很简单, 在项目属性->C/C+±>所有选项>语言中的符合模式项>>否即可!!就是这么任性, 记录一下以防以后忘掉了XXXX…

类定义2

#include<iostream>
#include<string>
using namespace std;
//   销售   项目
class Sales_item
{
public:
	Sales_item(std::string& book, unsigned units, double amount)
		:isbn(book), units_sold(units), revenue(amount)//std::写不写都行
	{}
	double avg_price() const//成员函数
	{
		if (units_sold)
			return revenue / units_sold;
		else
			return 0;
	}
	bool same_isbn(const Sales_item& rhs)const
	{
		return isbn == rhs.isbn;
	}
	void add(const Sales_item &rhs)//会修改
	{
		units_sold += rhs.units_sold;
		revenue += rhs.revenue;
	}
private:string isbn;//书号
	   unsigned units_sold;//销售数量
	   double revenue;//总金额
};
class Person
{

public:
	//成员
//公有成员写在前面
	Person(const string &nm,const string &addr):name(nm),address(addr)//初始化列表
		//把这两个参数保存到私有成员 
{
		/*name = nm;
		address = addr;*/ //和Person中:name(nm), address(addr)一样的效果
}

	//公有成员 可以在类的外部使用
public:string getName() const //不会修改 只读 
{
	return name;
}
public:string getAddress() const//不会修改 只读
{
	return address;
}
	  //一般私有成员写在后面
private:string name;//私有成员 只能在类的内部使用
private:string address;

};
int main()
{
	Person a("张飞","1号");

	//cout << a.name << "," << a.address;私有成员不可调用
	cout << a.getName() << "," << a.getAddress() << endl;

	Sales_item x(string("0-399-8247-1"),2,20.00);
	Sales_item y(string("0-399-82477-1"),6,48.00);

	if (x.same_isbn(y))
		x.add(y);

	cout << "两个销售单的平均价：" << x.avg_price() << endl;

	cout << x.avg_price() << endl;
	cout << y.avg_price() << endl;
	a.getName();
	a.getAddress();

	cout << "Hello 类！" << endl;
	return 0;
}

类定义（2）

• 同一类型的多个数据成员
• 使用类型别名来简化类(index)
• 成员函数可被重载–定义重载成员函数
• 显法指定inline成员函数

#include<iostream>

using namespace std;
class Screen {
	//写在类内部的并定义的函数 叫内联函数 Screen get()  get(index r,index c)
public:
	typedef std::string::size_type index;//别名index 代替所有的std::string::size_type类型

	Screen(index ht = 0, index wd = 0) :contents(ht* wd, 'A'), cursor(0), height(ht), width(wd)//构造函数 内联函数 因为该函数定义在类内部
	{}
	Screen(index ht, index wd, const std::string& conts);
	//get重载函数
	//成员函数的声明
	char get()const;//get 成员函数


	//char get(std::string::size_type r, std::string::size_type c)const //r表示行 c表示列
    inline char get(index r, index c)const; //r表示行 c表示列
	
private:
	std::string contents;//数据成员代表所有文字
	index cursor;//光标位置
	index height, width;
};
Screen::Screen(index ht, index wd, const std::string& conts):contents(conts),cursor(0),height(ht),width(wd)
{}

inline char Screen::get()const//不写inline的函数不是内联函数 写了inline 的函数叫内联函数
{
	return contents[cursor];//返回当前光标位置
}

char Screen::get(index r,index c)const//写作用域 Screen::
{
	index row = r * width;
	return contents[row + c];
}
int main()
{
	Screen a(10,9);
	cout << a.get();
	cout << a.get(2, 8) << endl;

	Screen b(3, 6, "hello screen class") ;//hello' ' 6个 screen 6个 class' '6个
	cout<< b.get()<<endl;
	cout << b.get(0, 4)<<b.get(1,2)<< endl;//hello 01234
	cout << "测试一下" << endl;
	return 0;
}

类定义(3)

• 类声明–前向声明
• 类定义
• 类对象
• 演变：C–C++

#include<iostream>
#include<string>

using namespace std;
class Screen;//类声明

class LinkScreen {
	Screen *window;
	LinkScreen* next;
	LinkScreen* prev;
};
class Y;
class X
{
	//各种成员略
private:
	Y* ptr;
};
class Y
{
	//各种成员略
private:
	X* ptr;
	X obj;
};

//    记录
class Record//这是一个完整的类：类定义，类声明
{

	
public:
	typedef std::size_t size;
	Record() :byte_count(0) {}
	Record(size s) :byte_count(s) {}
	Record(std::string s) :name(s), byte_count(0) {}

	size get_count()const { return byte_count; }
	std::string get_name()const { return name; }

private:
	size byte_count;
	std::string name;//记录名称
};
int main()
{
	Record r;//在堆栈上创建类的对象

	Record* p = new Record;//在堆栈动态创建对象

	delete p;
	//Screen scr; 这个scr对象报错 因为没有定义类Screen 

	Screen *scr;//指针可以
	cout << "hello" << endl;
	return 0;
}

C语言写的类

#include<stdio.h>

struct Person
{
	char name[30];
	char address[100];
};
int main()
{
	struct Person p;
	strcpy(p.name, "Bill");//报错 没有定义strcpy
	strcpy(p.address, "花园");

	printf("hello c!\n");
	printf("%s,%s\n", p.name, p.address);
	return 0;
}

隐含的this指针

• 何时使用this 指针
• 返回*this
• 从const 成员函数返回*this
• 基于const的重载
• 可变数据成员

this指针

• 下面这个cpp中this指针可写可不写

#include<iostream>
#include<string>

using namespace std;

class Person
{
public:
	Person(const std::string& nm, const std::string& addr)
	{
		this->name = nm;
		this->address = addr;
	}
	std::string getName()const
	{
		return this->name;//this指针在这里可写可不写 写了更清楚点
	}
    std::string getAddress()const
    {
		return this->address;
     }
private:
	std::string name;
	std::string address;
};
int main()
{
	Person p("张飞", "花园");
	Person p2("刘备", "花园");
	cout << p.getName() << endl;
	cout << p2.getAddress() << endl;
	return 0;
}

下面的要用this 遇到可以写可不写的时候 建议都写

#include<iostream>
#include<string>

using namespace std;

class Person
{
public:
	Person(const std::string& nm, const std::string& addr)
	{
		this->name = nm;
		this->address = addr;
	}
	std::string getName()const
	{
		return this->name;//this指针在这里可写可不写 写了更清楚点
	}
    std::string getAddress()const
    {
		return this->address;
     }
private:
	std::string name;
	std::string address;
};

class Screen//屏幕上的窗口
{
public:
	typedef std::string::size_type index;
	Screen(index ht = 0, index wd = 0) :contents(ht* wd, 'A '), cursor(0), height(ht),width(wd),access_ctr(0)
	{}
	char get() const { return contents[cursor]; }
	char get(index r, index c)const
	{
		index row = r * width;
		return  contents[row + c];
	}
	Screen& move(index r, index c);//此处不写void 
	Screen& set(index, index, char);
	Screen& set(char);
	const Screen& display(std::ostream& os) const//返回const
	{
		++access_ctr;
		do_display(os);
		return *this;
	}
	Screen display(std::ostream& os)//这是基于上面const的display的重载 不是const
	{
		++access_ctr;//计算display 用了几次
		do_display(os);
		return *this;
	}
private:
	std::string contents;
	index cursor;
	index height, width;
	//可变的
	mutable size_t access_ctr; //计数

	void do_display(std::ostream& os) const
	{
		os << contents;

	}
};
//
//Screen& Screen::move(index r, index c)
//{
//	index row = r * width;
//	cursor = row + c;
//}
Screen&Screen::set(index r, index c, char ch)
{
	index row = r * width;
	contents[row + c]=ch;
	return *this;

}
Screen& Screen::set(char c)
{
	contents[cursor] = c;
	return *this;
}
Screen& Screen::move(index r, index c)
{
	index row = r * width;
	cursor = row + c;
	return *this;//*this 表示间接引用或者解除引用
	//必须使用this指针返回对象 才能写87行的 myScreen.move(2,3).set('C');
}
int main()
{
	Person p("张飞", "花园");
	Person p2("刘备", "花园");

	cout << p.getName() << endl;
	cout << p2.getAddress() << endl;


	Screen myScreen(5, 3);
	cout << myScreen.get() << endl;
	myScreen.set(3, 2, 'B');
	cout << myScreen.get(3,2) << endl;
	//这两行是重点
	//myScreen.move(2, 3);
	//myScreen.set('C');

	//更简单的写法               非const                 const
     myScreen.move(2,3).set('C').display(cout).set('K').display(cout);//这个写法太漂亮！
	 cout << endl;
	 myScreen.move(4, 0).set('X').move(4, 1).set('Y').move(4, 2).set('Z').display(cout);
	 cout << endl;
	cout << myScreen.get() << endl;
	//       const
	myScreen.display(cout);
	cout << endl;

	return 0;
}

类作用域

• 1类作用域
• -使用类的成员
• -作用域与成员定义
• -形参表和函数处于类作用域中
• -函数返回类型不一定在类作用域中
• 2类作用域中的名字查找
• -类成员声明的名字查找
• 类成员定义中名字查找
• 类成员遵循常规的块作用域名字查找
• 函数作用域之后，在类作用域中查找
• 类作用域之后，在外围作用域查找

作用域1

#include<iostream>
#include<string>
using namespace std;

void doA()
{
	int a;
	a = 12;
}//a在上面花括号构成的作用域里
void doB()
{
	int b;
	b = 99;
}

class First
{
public:
	int memi;
	double memb;
public:
	void doC()//doC和memi在同一个作用域内可以相互调用
	{
		memi = 22;
	}

	void doD()
	{
		doC();
	}
};
int height;//全局作用域里的变量
class ScreenB
{
public:
	typedef std::string::size_type index;
	void dummy_fcn(index height)
	{
		//cursor = width * height;//这是哪一个height?
		//cursor = width * this->height;
		cursor = width * ::height;//全局作用域的变量height

	}
private:
	index cursor;
	index height, width;
};
class ScreenA
{
public:
	typedef std::string::size_type index;
	char get(index r, index c)const;
	index get_cursor() const;
private:
	std::string contents;
	index cursor;
	index height, width;
 };
ScreenA::index ScreenA::get_cursor() const
//ScreenA::get_cursor()说明get_cursor是ScreenA内的函数 ScreenA::index说明index是ScreenA内部的函数
{
	return cursor;
}
char ScreenA::get(index r,index c) const//在外边加上作用域操作符::
{
	index row = r * width;
	return contents[row + c];
}
int main()
{

	ScreenA::index ht;//作用域::
	ScreenA sa;
	ScreenB sb;
	doA();
	doB();//doB()是全局的 可以使用
	First obj;//先定义对象 
	First* ptr = &obj;
	obj.memi = 12;//通过对象obj使用memi是可以的
	obj.doC();//通过对象 可以使用doC()
	ptr->doC();
	ptr->memi = 99;
	return 0;
}

构造函数

• 作用：保证每个对象的数据成员具有合适的初始值
• 构造函数初始化（初始化列表）
• 默认实参与构造函数
• 默认构造函数
• 隐式类类型转换
  -类成员的显示初始化

必须用初始化列表的：

• const类型
• 引用类型
• 没有构造函数的类类型

#include<iostream>
#include<string>
using namespace std;

class Person
{
public:
	//默认构造函数
	Person() :age(0) {}
	//构造函数
	//                              初始化列表       
	Person(const std::string &nm,int a) :name(nm),age(a) {}//  加上const 否则输入"张飞"报错 
public:
	std::string name;
	int age;
};
class Cat
{
public:
	Cat() {}
	//构造函数 要是不写 c++会自动加一个构造函数为 Cat(){}
	Cat(std::string &nm) :name(nm),age(0) {}
	std::string getName() { return this->name; }
	int getAge() { return this->age; }
private:
	std::string name;
	int age;
};
class Dog
{
public:
	Dog():legs(4)
	{
	
	}
private:
	std::string name;
	const int legs;
};
class Sales_item
{
public:
	//explicit （显示的）  消除副作用
	explicit Sales_item(const std::string& book, int units, double price)
		:isbn(book), units_sold(units), revenue(units* price)//初始化列表的顺序 不是固定的
	{}
	                            //加了=""之后 就把Sales_item()函数注释掉否则报错
explicit Sales_item(const std::string& book=" ") :isbn(book), units_sold(0), revenue(0.0) {}//一个形参的有副作用
explicit Sales_item(std::istream& is) { is >> *this; }//一个形参的有副作用
	//构造函数 永远不需要const
explicit Sales_item(int units,double price)//标点，
	{
		this->units_sold = units;
		this->revenue = units * price;
	}
//	Sales_item():units_sold(0),revenue(0.0) {}//isbn的没有初始化 C++会自动初始化
	
	bool same_isbn(const Sales_item& rhs)const
	{
		return isbn == rhs.isbn;
	}
	friend std::istream& operator>>(std::istream&, Sales_item&);
private:
	std::string isbn;
	unsigned units_sold;
	double revenue;
};
inline istream& operator>>(istream& in, Sales_item& s)
{
	double price;
	in >> s.isbn >> s.units_sold >> price;
	if (in)
	
		s.revenue = s.units_sold * price;
	else
		s = Sales_item();
	return in;
	
}

//C->C++
//不能有构造函数 所有成员是public
class Data
{
public:
	int ival;
	char* ptr;
};
class Eata
{
public:
	Eata(int i, char* p) :ival(i), ptr(p) {}
private:
	int ival;
	char* ptr;
};

int main()
{
	Data v = { 9,"hello" };//C语言的写法
	Eata w(9, "hello");//C++的写法
	const int k = 10;
	
	Cat aCat;//不加() 加()表示函数

	Person a("张飞",22);
	Person b;//不加()

	Sales_item item1;//不加()
	Sales_item item2("13-3232-0");

	//if (item2.same_isbn("12-4213-9"))
	//{

	//}
	//if (item2.same_isbn(cin))
	//{

	//}
	Sales_item* p = new Sales_item();//这个()可写可不写 new调用构造函数
	const Sales_item item3;

	Sales_item myobj;//不加() 加了()会当成函数声明

	if (myobj.same_isbn(item2))
	{
		cout << "相同" << endl;
	}
	cout << a.name << endl;
	cout << a.age << endl;

	delete p;//用了new就要用delete 不要写*p 写p
	return 0;
}

友元–友元函数、友元类

• 友元关系
• 三种有元

普通函数（非成员函数）
类
类的成员函数

#include<iostream>

using namespace std;

class Screen;
class Dog
{
public:
	int foo(Screen& screen);
	
	int koo(Screen& screen);

};
class Screen
{
public:
	friend int calcArea(Screen&);
	friend class Window_Mgr;
	//friend class Dog; 把Dog里面的foo和koo都作为友元
	friend int Dog::foo(Screen&);
	typedef std::string::size_type index;
	//            默认值为0
	Screen(int ht, int wd = 0) :contents(ht* wd, ' '), cursor(0), height(ht), width(wd)
	{}
	//略

	int area() const
	{
		return height * width;
	}

private:
	std::string contents;
	index cursor;
	int height, width;
};

//普通函数
//这个函数不是类的成员函数
int calcArea(Screen& screen)
{
	return screen.height * screen.width;

}
class  Window_Mgr//窗口管理类 --对Screen进行管理
{
public:
	void relocate(int r, int c, Screen& s)//要用到Screen 
	{
		s.height += r;
		s.width += c;
	}
};

int Dog::foo(Screen& screen)
{
	return  screen.height * screen.width;
}

int Dog::koo(Screen&screen)
{
	return screen.area();//公有的area
}

int main()
{
	Screen a(60,100);

	cout << a.area() << endl;

	Window_Mgr wm;
	wm.relocate(20, 100, a);

	Dog dog;
	cout << dog.foo(a) << endl;
	cout << dog.koo(a) << endl;

	cout << calcArea(a) << endl;
	cout << "OK" << endl;
	return 0;
}

static类成员
静态的成员函数 不能使用this指针

• 使用类的static成员的优点

不同的类可以有同名的静态成员（属于类，不会和其他类的成员冲突）
可以封装（私有的）

• 定义static成员
• 使用类的static成员
• static成员函数
• static数据成员

#include<iostream>
#include<string>

using namespace std;

//全局变量
//double interestRate;

class Dog
{
   
};
class Account//账户
{
public:
	Account(std::string name, double money) :
		owner(name), amount(money) {}
	double getAmount() const
	{
		return this->amount;
	}
	void applyint() { amount += amount * interestRate; }
	void deposit(double money)//存钱
	{
		this->amount += money;
	}

static	double rate() { return interestRate; }
static	void rate(double newRate)
	{
		interestRate = newRate;
	}
private:
	std::string owner;//用户名
	double amount;//金额
	static double interestRate;//只有一个 静态的
	//	static double interestRate=0.2;不可以初始化
	static const int period = 30;//静态常量整型 才可以初始化
};
double Account::interestRate = 0.015;

int main()
{
	//interestRate = 0.015;

	Account::rate(0.026);//静态的函数 可以::这样做

	Account a("张三", 1000);
	a.deposit(500);
	Account b("李四", 2000);
	b.deposit(600);

	cout << a.getAmount() << endl;
	cout << b.getAmount() << endl;
	cout << a.rate() << endl;
	a.rate(0.018);
	cout << b.rate() << endl;

	Account::rate(0.02);
	a.applyint();
	b.applyint();
	cout << a.getAmount() << endl;
	cout << b.getAmount() << endl;
	return 0;
}

赋值操作符和复制构造函数

• 复制构造函数的适用情况

1.对象的定义形式----复制初始化
2.形参与返回值
3.初始化容器元素
4.构造函数与数组元素

• 赋值操作符

1.重载赋值操作符
2.复制和赋值常一起使用

• 合成的复制构造函数和赋值操作符
• 定义自己的复制构造函数和赋值操作符

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Sales_item
{
public:
	//公有的成员
	Sales_item() :units_sold(0), revenue(0.0) 
	{
		cout << "默认构造函数被调用" << endl;
	}
	Sales_item(const std::string& book) 
		:isbn(book), 
		units_sold(0),
		revenue(0.0)
	{
		cout << "构造函数Sales_item(const std::string &book)被用" << endl;
	}

	//复制构造函数
	//const &  把oring 一个一个复制给Sales_item
	Sales_item(const Sales_item& orig)
		:isbn(orig.isbn),
		units_sold(orig.units_sold), 
		revenue(orig.revenue)
	{
		cout << "复制构造函数被调用了！" << endl;
	}
	//赋值操作符
	Sales_item& operator=(const Sales_item&rhs)
	{
		cout << "赋值操作符被调用了！" << endl;
		isbn = rhs.isbn;
		units_sold = rhs.units_sold;
		revenue = rhs.revenue;
		return *this;
	}

private:
	std::string isbn;
	unsigned units_sold;
	double revenue;
};

class NoName
{
public:
	NoName() :pstring(new std::string), i(0), d(0) {}

	NoName(const NoName& other)
		:pstring(new std::string(*(other.pstring))), i(other.i), d(other.d)
	{
		cout << "NoName Copy Constructor" << endl;
	}

	/*NoName(const NoName& other)
		:pstring(other.pstring), i(other.i), d(other.d) {}*///C++自动写的

	NoName& operator=(const NoName& rhs)
	{
		cout << "NoName 赋值操作符" << endl;
		pstring = new std::string;
		*pstring = *(rhs.pstring);

		i = rhs.i;
		d = rhs.d;
		return *this;
	}
private:
	std::string* pstring;
	int i;
	double d;
};
Sales_item foo(Sales_item item)
{
	Sales_item temp;//默认构造函数
	temp = item;//赋值
	return temp;//
}
int main()
{
	NoName x,y;
	NoName z(x);
	x = y;

	Sales_item a;//默认构造函数
	Sales_item b("0-213-3243-X");
	//构造函数
	Sales_item c(b);//复制构造函数

	a = b;//赋值构造函数

	Sales_item item = string("9-999-9999-9");//构造函数

	cout << endl << "试一下foo:" << endl;
	Sales_item  ret;//默认构造
	ret = foo(item);//复制 实参复制到形参

	cout << endl << "试一下vector:" << endl;
	vector<Sales_item> svec(5);

	cout << endl << "试一下数组：" << endl;
	Sales_item primer_eds[] = {
		string("0-210-14523-3"),
		string("3-24-2555-2"),
		string("3-3223-3546-2"),
		Sales_item()
	};
	return 0;
}

析构函数

• 构造函数：获取资源
• 析构函数：释放资源
• -合成的析构函数
• -三法则（rule of three）

写了析构函数 就要写复制构造函数和赋值操作符

#include<iostream>

using namespace std;

class Sales_item
{
public:
	//成员（略）
private:
	std::string isbn;
	int units_sold;
	double revenue;
};
class NoName
{
public:
	NoName() :pstring(new std::string), i(0), d(0) 
	{
		//打开文件
		//连接数据库
		//动态分配内存
		cout << "构造函数被调用了！" << endl;
	}

	NoName(const NoName& other);
	~NoName();

	NoName& operator=(const NoName& rhs)
	{
		pstring = new std::string;
		*pstring = *(rhs.pstring);
		i = rhs.i;
		d = rhs.d;
		return *this;
	}
private:
	std::string* pstring;
	int i;
	double d;
};

NoName::NoName(const NoName& other)
{
	pstring = new std::string;
	*pstring = *(other.pstring);
	i = other.i;
	d = other.d;
}
NoName::~NoName()
{
	//关闭文件
	//关闭数据库
	//回收动态分配的内存
	cout << "析构函数被调用了！\n" << endl;
	delete pstring;
}
int main()
{
	NoName a;

	NoName* p = new NoName;//delete和new是一对

	delete p;

	cout << "Hello\n" << endl;
	return 0;
}

深复制、浅复制

• 复制构造函数/拷贝构造函数
• 浅复制/浅拷贝/位拷贝
• 深复制/深拷贝

#include<iostream>

using namespace std;

class CDemo
{
public:
	CDemo(int pa, char* cstr)
	{
		this->a = pa;
		this->str = new char[1024];
		strcpy(this->str, cstr);//拷贝
	}
	//复制构造函数没写 C++自动构造一个复制构造函数如下:
	//CDemo(CDemo& obj)
	//{
	//	this->a = obj.a;
	//	this->str = obj.str;//这里不对，要深复制才行，这是浅复制
	//}

	CDemo(CDemo& obj)
	{
		this->a = obj.a;
		this->str = new char[1024];
		if (str != 0)
			strcpy(this->str, obj.str);
	}
	~CDemo()
	{
		delete str;//new和delete 一对的
	}
//private:应该是私有的
public:
	int a;
	char* str;//有指针 要创建构造函数 和 深复制

};

int main()
{
	CDemo A(10, "hello");

	CDemo B = A;//复制  A中的10和hello复制给B
	cout << A.a << ","<<A.str << endl;
	cout << "A:" << A.a << "," << A.str << endl;
	cout << "B:" << B.a << "," << A.str << endl;
	B.a = 8;
	B.str[0] = 'K';
	cout << "修改以后：" << endl;
	cout << "A:" << A.a << "," << A.str << endl;
	cout << "B:" << B.a << "," << B.str << endl;
	return 0;
}

管理指针成员
三种方法

• 1.常规指针类（浅复制）
• 2.智能指针类（计数类）
• 3。