C到C++的弱进阶教程

指针变量

动态内存分配

1 指针

1.1 指针与普通变量

1.2 指针与数组

1.3 指针与动态内存分配

T * p= new T;
delete p;
T * q=new T[15];
delete[] q;

#include <iostream>
#include <windows.h>
#include 
using namespace std;

int main()
{
#if 0
	int a = 3;
	int *p = &a;
	cout << p << '\t' << &a << endl;
	cout << *p << '\t' << a << endl;
	*p = 5;
	cout << *p << '\t' << a << endl;
	
#endif 

#if 1
	int arry[] = { 10,20,30,40 };
	int *p = arry;
	cout << *(p + 2) << '\t' << p[2] <<'\t'<< arry[2]<< endl;

	for (int *q = p + 4; p < q; p++)
	{
		cout << *p << '\t' << endl;
	}

#endif


#if 1
	int *p = new int; //malloc        //堆存储区
	*p = 3;                           //栈存储区
	cout << p << '\t' << *p << endl;
	delete p;                         //如果不delete可能会导致内存泄漏

	p = new int;
	*p = 5;
	cout << p << '\t' << *p << endl;
	delete p;

#endif

	system("pause");
	return 0;
}

/*
Result 0
008FFB2C        008FFB2C
3       3
5       5
5 		5		5

Result 1
30      30      30
10
20
30
40

Result 2
00CEA270        3
00CEA270        5
*/

2 引用变量，引用形参

2.1 引用变量：引用变量其实就是给变量起了个外号，对引用变量的更改也会造成变量的更改
2.2 引用形参：使用引用形参的函数不必再push新的变量入栈 可以用实参的引用变量来对实参进行操作

3 函数默认形参，函数重载

3.1 函数默认形参
可以对函数使用默认形参，但是要主义的是默认形参必须往右边靠
void set_name_age_sex(string name, int age=18,string sex=“male”);
void set_name_age_sex(int age=18,string name, string sex=“male”); //非法的 编译器会报错 它找第一个有默认值的形参后就会认为后面的参数都是有默认值的

3.2 函数重载
C++的函数支持重载，也就是说两个函数的完全一样是指 函数签名（函数名+返回类型+形参类型 ）完全一样
函数重载一定程度上让函数调用对于变量类型的要求更模糊：
int add( int a,int b)
double add( double a,double b)
add函数传入int类型时会调用上面一个 add函数传入double类型时会调用下面一个

4 函数模板

让同一个函数可以操作任何类型参数成为可能，也称泛型
用temolate关键字加一个模板头，将数据类型变成类型模板参数

//制作模板
template<class T>`在这里插入代码片`
T add(T x,T y)
{
	return x+y;
}

//模板实例化
cout << add<int>(5,3) << endl;                 //遇到一个实例化编译器就会产生一个该类型的函数
cout << add<double>(5.1,7.9) << endl;
cout << add<string>("hello","world") << endl;
cout << add<int>(51,31) << endl;               //再次遇到时编译器不再生成
 

this指针

当我们使用成员访问符来使用一个实例内的方法时其实编译器做了处理，

student stu;
stu.print();       // ------------> print(&stu);

//同样的 既然print函数里面出现了参数 他的函数原型也需要一个形参 这个形参就是this指针，他指向当前程序所访问的实例所在的首地址,可以让类函数变成普通函数
class student{
	int score;
	string name;
	void print()   //-------------------------->void print(student * this)
	{cout << name << " " << score <<endl; }//-->{cout <<this->name << " " << this->score <<endl; }-
//你甚至可以在成员函数内部显式地使用this指针
}

访问控制

没什么好说的，默认类中的成员都是私有(private)的，需要使用pulice关键字声明公有
为了数据封装，需要让数据私有，外部 通过公有的函数来访问数据

构造函数

构造函数：函数名和类名相同且无返回类型的成员函数,实例在构造时被运行的函数
如果不显式地去写构造函数，那么编译器会自动生成一个什么都不做的构造函数

class student{

 string name;
 double score;
public:
 student(string n,double s){
name=n;score=s;
}

void print(){
cout << name<<" "<<score<<endl;
}

int main()
{
	student stu("liping",18);
	stu.print();
}

}

类比到python

class student():
	def __init__(self,n,s);
	self.name=n;
	self.score=s;

	def prints(self):
		print(self.name+" "+ self.score)

if __name__ == __main__:
	stu=student("liping",18)
	stu.prints()

运算符重载：

cout << stu: //出错 cout无法识别stu；
如果我想自己定制cout 的运算符“<<”所能识别的数据类型 我们可以对运算符做出重载
当然不仅可以定制<< 还可以定制点运算符“ .” 下标运算符 “[ ]”

class student{

 string name;
 double score;
public:
 student(string n,double s){
name=n;score=s;}

void print()
{
cout << name<<" "<<score<<endl;

friend ostream& operator<<(ostream &o,student s);      //友元函数 让外部函数operator可以访问类内部的属性
friend istream& operator<<(istream &o,student s);      //友元函数 让外部函数operator可以访问类内部的属性
}


}

}
ostream& operator<<(ostream &o,student s)
{
	o << s.name << " " << s.score <<endl;
	return o;
}
ostream& iperator<<(istream &in,student s )
{
	in >> s.name >> s.score;
	return o;
}

int main(){
	student stu("liping",18);
	cin >> stu;     //--------------->operator>>(cin,stu);
	cout << stu;    //--------------->operator<<(cout,stu);
	
}

拷贝构造和析构函数

//实现自己的String

#include <iostream>
using namespace std;

class String {
	char * data;
	int n;
public:
	String(const char * s = 0)
	{
		if (s == 0)
		{
			data = 0; n = 0; return;

		}

		const char * p = s;//基地址
		while (*p) p++;    //尾地址
		n = p - s;         //偏移量
		data = new char[n + 1];  //分配存储data的内存块
		for (int i = 0; i < n; i++)
		{
			data[i] = s[i];
		}
		data[n] = '\0';    //形参s拷贝到data
		
	}

	int get_size() { return n; }

	//下标访问
	char operator[] (int i)const {
		if (i < 0 || i >= n)
		{
			throw "Invalid Sub";
			cout << "Invalid Sub";
		}
		
		return data[i];
	}

	//下标更改
	char& operator[] (int i){
		if (i < 0 || i >= n) throw "Invalid Sub";

		return data[i];
	}

};


int main()
{
	String str, str2("hello world");
	str2[1] = 'E';
	for (int i = 0; i < str2.get_size(); i++)
	{
		cout << str2[i];
	}

	String
	system("pause");
}

类模板

类比函数模板

template<class  T>
class Vector{

......

}

Vector<string> v;