C++学习笔记（1）
C++学习笔记（1）
泛型模板排序
template<typename T> //定义一个泛型类型T
/// <summary>
/// 定义一个模板方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="a"></param>
/// <param name="b"></param>
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
template<class T>
void mySort(T arry[], int len)
{
for (int i = 0; i < len; i++)
{
int max = i;
for (int j = i + 1; j < len; j++)
{
if (arry[max] < arry[j]) { max = j; }
}
if (max != i)mySwap(arry[max], arry[i]);
}
}
template<class T>
void mySort2(T arry[], int len)
{
for (int i = 0; i < len; i++)
{
int min = i;
for (int j = i + 1; j < len; j++)
{
if (arry[min] > arry[j]) { min = j; }
}
if (min != i)mySwap(arry[min], arry[i]);
}
}
#include<iomanip>
void test5()
{
char ca[] = "adkblnvg";
int len = sizeof(ca) / sizeof(ca[0]) - 1;
cout << setw(20) << "排序前 " << ca << endl;
mySort(ca,len);
cout << setw(20) <<"从大到小排序后 " << ca << endl;
mySort2(ca, len);
cout << setw(20) << "从小到大排序后 " << ca << endl;
cout << "----------------------------------------\n";
int ai[] = {1,5,9,6,3,4,7,2,8,0};
len = sizeof(ai) / sizeof(ai[0]) - 1;
cout << setw(20) << "排序前 " ;
for (size_t i = 0; i < len; i++)
{
cout << ai[i] << ",";
}
cout << endl;
mySort(ai, len);
cout << setw(20) << "从大到小排序后 " ;
for (size_t i = 0; i < len; i++)
{
cout << ai[i] << ",";
}
cout << endl;
mySort2(ai, len);
cout << setw(20) << "从小到大排序后 " ;
for (size_t i = 0; i < len; i++)
{
cout << ai[i] << ",";
}
cout << endl;
}运行结果
模板和泛型template
template<typename T> //定义一个泛型类型T
/// <summary>
/// 定义一个模板方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="a"></param>
/// <param name="b"></param>
void mySwap(T &a,T &b)
{
T temp=a;
a = b;
b = temp;
}
//模板测试
void test4()
{
char a = 'A',b='B';
mySwap(a, b);//隐式类型推导
cout << "a=" << a << " b=" << b << endl;
string s1 = "黑马程序员";
string s2 = "C++教程从0到1入门编程";
mySwap(s1,s2);//隐式类型推导
cout << "s1=" << s1 << " s2=" << s2 << endl;
double b1 = 3.14, b2 = 5.678;
mySwap<double>(b1, b2);//显式指定类型<T>
cout << "b1=" << b1 << " b2=" << b2 << endl;
}运行结果
模板定义：将类型参数化，提高代码复用性；模板关键字template，
模板使用方法：1自动类型推导2显式指定类型
模板注意事项：
- 自动类型推导，必须推导出一致的数据类型T，才可以使用模板；
- 模板必须确定出T的类型，才可以使用；
-------------------------------------------------------------
参数传递的三种方式
- 值传递
- 引用传递
- 指针传递
void test14()
{
int a = 666, b = 888;
cout << "数值交换前" << " a=" << a << " b=" << b << endl;
swapv(a, b);
cout<<"数值交换后" << " a=" << a << " b=" << b << endl;
cout << "-----------------------------" << endl;
int* pa = &a; int* pb = &b;
cout << "指针交换前" << " a=" << a << " b=" << b << endl;
swapp(pa,pb);
cout << "指针交换后" << " a=" << a << " b=" << b << endl;
cout << "-----------------------------" << endl;
int& ra = a; int& rb = b;
cout << "引用交换前" << " a=" << a << " b=" << b << endl;
swapr(ra,rb);
cout << "引用交换后" << " a=" << a << " b=" << b << endl;
}运行结果
引用&测试
void test13()
{
int a = 100;
int& b = a;
cout << "b=" << b << " a=" << a << endl;
cout << "(int)&b=" << (int)&b << " (int)&a=" << (int)&a << endl;
//b = 100 a = 100
//(int)&b = 13629100 (int)&a = 13629100
a++;
cout << "b=" << b << " a=" << a << endl;
cout << "(int)&b=" << (int)&b << " (int)&a=" << (int)&a << endl;
b++;
cout << "b=" << b << " a=" << a << endl;
cout << "(int)&b=" << (int)&b << " (int)&a=" << (int)&a << endl;
int* p = &a;
(*p)++;
cout << "b=" << b << " a=" << a << endl;
cout << "(int)&b=" << (int)&b << " (int)&a=" << (int)&a << endl;
//int& c;//错误，引用不可以先声明，再赋值
//int* p1;//正确，指针可以先声明，再赋值
int c = 66;
b = c;
cout << "b=" << b << " a=" << a << " c=" << c << endl;
cout << "(int)&b=" << (int)&b << " (int)&a=" << (int)&a << " (int)&c=" << (int)&c << endl;
}运行结果
b虽然被赋值成了c，但是b的地址依然指向第一次赋值的a，只是把c的值复制过来了；
可见引用的地址不可改变，相当于指针常量int * const p;
指针常量可以更改指针所指向的值，而不可以更改指针的指向（地址）；
编译器自动类型转换int--double--int
void cheers(uint n)
{
for (size_t i = 0; i < n; i++)
{
cout << "Cheers!" << endl;
}
}
double cube(double side)
{
return side * side * side;
}
void test12()
{
//编译器：首先将int类型2转换为double类型2.0，以匹配cube函数的类型要求
//编译器：将cube（2）的double类型返回值8.0转换为usigned int类型8，以匹配cheers函数的类型要求；
cheers(cube(2));
}运行结果
数组的替代选项---模板类vector、array
void test11()
{
unsigned short n = 10;
const unsigned short m =10;
vector<int> vi;
vector<double>vd(n);
array<int, 5> ai;
//m必须是常量，而不能是变量，可以是一个数值10，或者const unsigned int类型的变量
array<double, m> ad = { 1.0,2.0,3.0,4.0 };
//-------------------------------------
double a1[4] = { 1.1,2.2,3.3,4.4 };//静态数组，必须在定义时指定长度
//a1[-1] = -1.0;//错误，索引值超出索引范围0-3
//double a2[];//错误，静态数组必须在定义时指定长度
//double a2[4]=a1;//错误，应该使用{}初始化聚合对象
//a2 = a1;//错误，应该使用{}初始化聚合对象
vector<double> vd1={ 2.22,3.25,5.65,6.74 };
vector<double>vd2{ 2.22,3.25,5.65,6.74 };//可以省略等号进行便捷初始化
vector<double> vd3(4);//不能直接初始化
vd3= { 2.22,3.25,5.65,6.74 };
vector<double>vd4(3);
vd4[0] = 1.23;
vd4[1] = 3.22;
cout << "vd4[0] " << vd4[0] << endl;
cout << "vd4[1] " << vd4[1] << endl;
cout << "vd4[2] " << vd4[2] << endl;
cout << "-------------------------" << endl;
vector<double> vd5 = vd4;
cout << "&vd4[i] " << "&vd5[i]" << endl;
cout << &vd4[0] <<" " << &vd5[0] << endl;
cout << &vd4[1] << " " << &vd5[1] << endl;
cout << &vd4[2] << " " << &vd5[2] << endl;
array<double, 4> arr1{ 5.0,6.0,7.0,8.0 };
//array<double, 5> arr2=arr1;//错误，必须长度相等才可以赋值
//array<long double, 4>arr3 = arr1;//错误，必须类型相同才可以赋值
array<double, 4>arr4 = arr1;
cout << "-------------------------" << endl;
cout << "&arr4[i] " << "&arr1[i]" << endl;
cout << &arr4[0] << " " << &arr1[0] << endl;
cout << &arr4[1] << " " << &arr1[1] << endl;
cout << &arr4[2] << " " << &arr1[2] << endl;
}运行结果
vector之间可以直接=赋值，赋值后的vector是原vector的一个拷贝；
array之间可以直接=赋值，必须满足两个条件
1、array长度必须相等；
2、元素类型必须完全相同；
赋值后的array是原array的一个拷贝；
指向指针的指针
struct years
{
int year;
bool isLeepYear;
};
void test10()
{
years y1, y2, y3;
y1.year = 1998; //成员运算符，用变量名访问成员
years* py = &y2;
py->year = 1999; //间接成员运算符，用指针访问成员
years arry[3]; //结构体数组
arry[0].year = 2003; arry[1].year = 2004; arry[2].year = 2005;
cout<<"arry->year " << arry->year << endl;
cout << "arry[1].year " << arry[1].year << endl;
cout << "arry->year " << arry->year << endl;
cout << "-------------------------"<<endl;
years* arryp[3] = { &y1,&y2,&y3 };//结构体指针数组
cout << "arryp[1]->year " << arryp[1]->year << endl;
//数组元素本身是指针（指向结构体），
//而数组名也是指针（指向数组的第一个元素），
//所以这里的数组名是指向指针的指针years**
years** ppa = arryp;
auto ppb = arryp;
cout << "-------------------------" << endl;
cout << "(*ppa)->year " << (*ppa)->year << endl;
cout << "(*(ppb + 1))->year " << (*(ppb + 1))->year << endl;
}运行结果
字符串测试
typedef unsigned int uint;
char* getname()
{
char temp[80];
cout << "Enter name (less than 80 characters)" << endl;
cin >> temp;
uint len = strlen(temp);
cout << "len=" << len << endl;
//通过一个小的内存空间来存放输入，以节省内存
char* pc = new char[len + 1];
//len表示字符串中字符的个数，而没有包含字符串结束标识"\0"
//字符串所占字节数应当包含结束标识"\0"，所以为len+1
//strcpy已过时弃用，这里使用更加安全的strcpy_s
//第一个参数表示拷贝的目标指针，char*类型
//第二个参数表示需要拷贝的字节数，包含结束标识"\0"，所以为len+1，
// rsize_t类型，rsize_t类型属于size_t类型，而size_t类型属于unsigned int类型
// rsize_t类型实际就是unsigned int类型，二者等效
//第三个参数表示需要拷贝的数据源const char*类型
strcpy_s(pc, len+1, temp);
return pc;
}
void test9()
{
char* name;
name = getname();
cout << "name=" << name << " name at=" << (int*)name << endl;
//只能释放new的资源
delete name;
name = getname();
cout << "name=" << name << " name at=" << (int*)name << endl;
//只能释放new的资源
delete name;
}运行结果
打开文件是否成功的测试
void test2()
{
ifstream instream;
instream.open("in.dat");
string s = instream.fail() ? "fail" : "succeed";
cout <<"instream.fail()? " << instream.fail() << endl;
cout << "instream.fail()? " << s << endl;
if (!instream.fail())instream.close();
instream.open("inFile.dat");
s = instream.fail() ? "fail" : "succeed";
cout << "instream.fail()? " << instream.fail() << endl;
cout << "instream.fail()? " << s << endl;
if (!instream.fail())instream.close();
}运行结果
文件流测试
#include<iostream>
#include <fstream>
using namespace std;
void test1()
{
ifstream inStream;
ofstream outStream;
inStream.open("inFile.dat");
outStream.open("outFile.dat");
int first, second, third;
inStream >> first >> second >> third;
cout << "first=" << first << " second=" << second << " third=" << third << endl;
cout << "sum=" << first + second + third << endl;
outStream << "first=" << first << " second=" << second << " third=" << third << endl;
outStream << "sum=" << first + second + third << endl;
inStream.close();
outStream.close();
}
运行结果
