#include<iostream>
#include<string>
using namespace std;
//类型转换
void Insert(size_t pos, char ch)
{
size_t _size = 5;
//....
int end = _size - 1;
while (end >= pos) // end隐式类型转换
{
//_str[end + 1] = _str[end];
--end;
}
}
void Test1()
{
int i = 1;
// 隐式类型转换(意义相近的类型)
double d = i;
printf("%d, %.2f\n", i, d);
int* p = &i;
// 显示的强制类型转换(意义不相近的类型，值转换后有意义)
int address = (int)p;
printf("%x, %d\n", p, address);
Insert(3, 'a');
Insert(0, 'a');
}
int main()
{
Test1();
return 0;
}
是会有一点问题的。
static_cast 支持相近类型的转换
reinterpret_cast支持不相近类型的转换
int main()
{
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;
int* p = &a;
// 不支持的
//int address = static_cast<int>(p);
int address = reinterpret_cast<int>(p);
return 0;
}
要小心使用的const_cast
int main()
{
const int a = 2;
int* p = const_cast<int*>(&a);
*p = 3;
cout << a << endl;
cout << *p << endl;
return 0;
}这是控制台结果，我们还可以看一下监视和反汇编
从反汇编我们可以看到a直接呗替换成了常量 2
监视窗口下我们发现 a和*p的值都是2
这都源于编译器对代码进行的优化
我们通过添加volatile关键字来取消这种优化
int main()
{
/*const int a = 2;*/
volatile const int a = 2;
int* p = const_cast<int*>(&a);
*p = 3;
cout << a << endl;
cout << *p << endl;
return 0;
}
dynamic_cast
class A
{
public:
virtual void f(){}
public:
int _a = 0;
};
class B : public A
{
public:
int _b = 1;
};
// A*指针pa有可能指向父类，有可能指向子类
void fun(A* pa)
{
// 如果pa是指向子类，那么可以转换，转换表达式返回正确的地址
// 如果pa是指向父类，那么不能转换，转换表达式返回nullptr
B* pb = dynamic_cast<B*>(pa); // 安全的
//B* pb = (B*)pa; // 不安全
if (pb)
{
cout << "转换成功" << endl;
pb->_a++;
pb->_b++;
cout << pb->_a << ":" << pb->_b << endl;
}
else
{
cout << "转换失败" << endl;
pa->_a++;
cout << pa->_a << endl;
}
}
int main()
{
A aa;
// 父类对象无论如何都是不允许转换成子类对象的
/*B bb = dynamic_cast<B>(aa);
B bb = (B)aa;*/
B bb;
fun(&aa);
fun(&bb);
//fun(nullptr);
return 0;
}
C的这种用法hi能出结果，（运行不会被中断的）
class A1
{
public:
//virtual void f(){}
public:
int _a1 = 0;
};
class A2
{
public:
//virtual void f(){}
public:
int _a2 = 0;
};
class B : public A1, public A2//多继承
{
public:
int _b = 1;
};
int main()
{
B bb;
A1* ptr1 = &bb;
A2* ptr2 = &bb;
cout << ptr1 << endl;
cout << ptr2 << endl << endl;
B* pb1 = (B*)ptr1;
B* pb2 = (B*)ptr2;
cout << pb1 << endl;
cout << pb2 << endl << endl;
return 0;
}
但是我们观察一下对象内部的成员
IO流
int main()
{
//2023 8 29
//输入多个值，默认都是用空格或者换行分割
int year, month, day;
cin >> year >> month >> day;
scanf("%d%d%d", &year, &month, &day);
scanf("%d %d %d", &year, &month, &day); //不需要去加空格
return 0;
}三种写法都是可以的
处理连续型
int main()
{
int year, month, day;
scanf("%4d%2d%2d", &year, &month, &day);
string str;
cin >> str;
year = stoi(str.substr(0, 4));
month = stoi(str.substr(4, 2));
day = stoi(str.substr(6, 2));
return 0;
}格式必须正确
类型转换
int main()
{
// 内置类型 转换成自定义类型
A aa1 = 1; // 隐式类型转换 用1构造A临时对象，再拷贝构造aa1，优化后直接1构造aa1
// 自定义类型 转换成内置类型
int i = aa1;
return 0;
}
class Date
{
friend ostream& operator << (ostream& out, const Date& d);
friend istream& operator >> (istream& in, Date& d);
public:
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{}
operator bool()
{
// 这里是随意写的，假设输入_year为0，则结束
if (_year == 0)
return false;
else
return true;
}
private:
int _year;
int _month;
int _day;
};
istream& operator >> (istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
ostream& operator << (ostream& out, const Date& d)
{
out << d._year << " " << d._month << " " << d._day;
return out;
}
C++ IO流，使用面向对象+运算符重载的方式
能更好的兼容自定义类型，流插入和流提取
int main()
{
// 自动识别类型的本质--函数重载
// 内置类型可以直接使用--因为库里面ostream类型已经实现了
int i = 1;
double j = 2.2;
cout << i << endl;
cout << j << endl;
// 自定义类型则需要我们自己重载<< 和 >>
Date d(2022, 4, 10);
cout << d;
while (d)
{
cin >> d;
cout << d;
}
return 0;
}
将test.cpp的内容打印到控制台上
int main()
{
ifstream ifs("test.cpp");
char ch = ifs.get();
while (ifs)
{
cout << ch;
ch = ifs.get();
}
return 0;
}
