五万字读懂c++
Posted C语言与CPP编程
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了五万字读懂c++相关的知识,希望对你有一定的参考价值。
修饰变量,说明该变量不可以被改变; 修饰指针,分为指向常量的指针(pointer to const)和自身是常量的指针(常量指针,const pointer); 修饰引用,指向常量的引用(reference to const),用于形参类型,即避免了拷贝,又避免了函数对值的修改; 修饰成员函数,说明该成员函数内不能修改成员变量。
const 的指针与引用
(为了方便记忆可以想成)被 const 修饰(在 const 后面)的值不可改变,如下文使用例子中的
p2
、p3
使用
const 使用
// 类
class A
private:
const int a; // 常对象成员,可以使用初始化列表或者类内初始化
public:
// 构造函数
A() : a(0) ;
A(int x) : a(x) ; // 初始化列表
// const可用于对重载函数的区分
int getValue(); // 普通成员函数
int getValue() const; // 常成员函数,不得修改类中的任何数据成员的值
;
void function()
// 对象
A b; // 普通对象,可以调用全部成员函数
const A a; // 常对象,只能调用常成员函数
const A *p = &a; // 指针变量,指向常对象
const A &q = a; // 指向常对象的引用
// 指针
char greeting[] = "Hello";
char* p1 = greeting; // 指针变量,指向字符数组变量
const char* p2 = greeting; // 指针变量,指向字符数组常量(const 后面是 char,说明指向的字符(char)不可改变)
char* const p3 = greeting; // 自身是常量的指针,指向字符数组变量(const 后面是 p3,说明 p3 指针自身不可改变)
const char* const p4 = greeting; // 自身是常量的指针,指向字符数组常量
// 函数
void function1(const int Var); // 传递过来的参数在函数内不可变
void function2(const char* Var); // 参数指针所指内容为常量
void function3(char* const Var); // 参数指针为常量
void function4(const int& Var); // 引用参数在函数内为常量
// 函数返回值
const int function5(); // 返回一个常数
const int* function6(); // 返回一个指向常量的指针变量,使用:const int *p = function6();
int* const function7(); // 返回一个指向变量的常指针,使用:int* const p = function7();
宏定义 #define 和 const 常量
宏定义 #define | const 常量 |
---|---|
宏定义,相当于字符替换 | 常量声明 |
预处理器处理 | 编译器处理 |
无类型安全检查 | 有类型安全检查 |
不分配内存 | 要分配内存 |
存储在代码段 | 存储在数据段 |
可通过 #undef 取消 | 不可取消 |
作用
修饰普通变量,修改变量的存储区域和生命周期,使变量存储在静态区,在 main 函数运行前就分配了空间,如果有初始值就用初始值初始化它,如果没有初始值系统用默认值初始化它。 修饰普通函数,表明函数的作用范围,仅在定义该函数的文件内才能使用。在多人开发项目时,为了防止与他人命名空间里的函数重名,可以将函数定位为 static。 修饰成员变量,修饰成员变量使所有的对象只保存一个该变量,而且不需要生成对象就可以访问该成员。 修饰成员函数,修饰成员函数使得不需要生成对象就可以访问该函数,但是在 static 函数内不能访问非静态成员。
this
指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向调用该成员函数的那个对象。当对一个对象调用成员函数时,编译程序先将对象的地址赋给
this
指针,然后调用成员函数,每次成员函数存取数据成员时,都隐式使用this
指针。当一个成员函数被调用时,自动向它传递一个隐含的参数,该参数是一个指向这个成员函数所在的对象的指针。
this
指针被隐含地声明为:ClassName *const this
,这意味着不能给this
指针赋值;在ClassName
类的const
成员函数中,this
指针的类型为:const ClassName* const
,这说明不能对this
指针所指向的这种对象是不可修改的(即不能对这种对象的数据成员进行赋值操作);this
并不是一个常规变量,而是个右值,所以不能取得this
的地址(不能&this
)。在以下场景中,经常需要显式引用
this
指针:
为实现对象的链式引用; 为避免对同一对象进行赋值操作; 在实现一些数据结构时,如 list
。
特征
使用
inline 使用
// 声明1(加 inline,建议使用)
inline int functionName(int first, int second,...);
// 声明2(不加 inline)
int functionName(int first, int second,...);
// 定义
inline int functionName(int first, int second,...) /****/;
// 类内定义,隐式内联
class A
int doA() return 0; // 隐式内联
// 类外定义,需要显式内联
class A
int doA();
inline int A::doA() return 0; // 需要显式内联
编译器对 inline 函数的处理步骤
将 inline 函数体复制到 inline 函数调用点处; 为所用 inline 函数中的局部变量分配内存空间; 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中; 如果 inline 函数有多个返回点,将其转变为 inline 函数代码块末尾的分支(使用 GOTO)。
优缺点
优点
内联函数同宏函数一样将在被调用处进行代码展开,省去了参数压栈、栈帧开辟与回收,结果返回等,从而提高程序运行速度。 内联函数相比宏函数来说,在代码展开时,会做安全检查或自动类型转换(同普通函数),而宏定义则不会。 在类中声明同时定义的成员函数,自动转化为内联函数,因此内联函数可以访问类的成员变量,宏定义则不能。 内联函数在运行时可调试,而宏定义不可以。
缺点
代码膨胀。内联是以代码膨胀(复制)为代价,消除函数调用带来的开销。如果执行函数体内代码的时间,相比于函数调用的开销较大,那么效率的收获会很少。另一方面,每一处内联函数的调用都要复制代码,将使程序的总代码量增大,消耗更多的内存空间。 inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译,不像 non-inline 可以直接链接。 是否内联,程序员不可控。内联函数只是对编译器的建议,是否对函数内联,决定权在于编译器。
虚函数(virtual)可以是内联函数(inline)吗?
Are "inline virtual" member functions ever actually "inlined"?
inline virtual
唯一可以内联的时候是:编译器知道所调用的对象是哪个类(如 Base::who()
),这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。虚函数内联使用
#include <iostream>
using namespace std;
class Base
public:
inline virtual void who()
cout << "I am Base\\n";
virtual ~Base()
;
class Derived : public Base
public:
inline void who() // 不写inline时隐式内联
cout << "I am Derived\\n";
;
int main()
// 此处的虚函数 who(),是通过类(Base)的具体对象(b)来调用的,编译期间就能确定了,所以它可以是内联的,但最终是否内联取决于编译器。
Base b;
b.who();
// 此处的虚函数是通过指针调用的,呈现多态性,需要在运行时期间才能确定,所以不能为内联。
Base *ptr = new Derived();
ptr->who();
// 因为Base有虚析构函数(virtual ~Base() ),所以 delete 时,会先调用派生类(Derived)析构函数,再调用基类(Base)析构函数,防止内存泄漏。
delete ptr;
ptr = nullptr;
system("pause");
return 0;
volatilevolatile int i = 10;
断言,是宏,而非函数。assert 宏的原型定义在 <assert.h>
(C)、<cassert>
(C++)中,其作用是如果它的条件返回错误,则终止程序执行。可以通过定义 NDEBUG
来关闭 assert,但是需要在源代码的开头,include <assert.h>
之前。
assert() 使用
#define NDEBUG // 加上这行,则 assert 不可用
#include <assert.h>
assert( p != NULL ); // assert 不可用
sizeof()设定结构体、联合以及类成员变量以 n 字节方式对齐
#pragma pack(n) 使用
#pragma pack(push) // 保存对齐状态
#pragma pack(4) // 设定为 4 字节对齐
struct test
char m1;
double m4;
int m3;
;
#pragma pack(pop) // 恢复对齐状态
位域Bit mode: 2; // mode 占 2 位
类可以将其(非静态)数据成员定义为位域(bit-field),在一个位域中含有一定数量的二进制位。当一个程序需要向其他程序或硬件设备传递二进制数据时,通常会用到位域。
extern "C"
修饰的变量和函数是按照 C 语言方式编译和链接的extern "C"
的作用是让 C++ 编译器将 extern "C"
声明的代码当作 C 语言代码处理,可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。
extern "C" 使用
#ifdef __cplusplus
extern "C"
#endif
void *memset(void *, int, size_t);
#ifdef __cplusplus
#endif
struct 和 typedef structC 中
// c
typedef struct Student
int age;
S;
等价于
// c
struct Student
int age;
;
typedef struct Student S;
此时 S
等价于 struct Student
,但两个标识符名称空间不相同。
另外还可以定义与 struct Student
不冲突的 void Student()
。
C++ 中
由于编译器定位符号的规则(搜索规则)改变,导致不同于C语言。
一、如果在类标识符空间定义了 struct Student ...;
,使用 Student me;
时,编译器将搜索全局标识符表,Student
未找到,则在类标识符内搜索。
即表现为可以使用 Student
也可以使用 struct Student
,如下:
// cpp
struct Student
int age;
;
void f( Student me ); // 正确,"struct" 关键字可省略
二、若定义了与 Student
同名函数之后,则 Student
只代表函数,不代表结构体,如下:
typedef struct Student
int age;
S;
void Student() // 正确,定义后 "Student" 只代表此函数
//void S() // 错误,符号 "S" 已经被定义为一个 "struct Student" 的别名
int main()
Student();
struct Student me; // 或者 "S me";
return 0;
C++ 中 struct 和 class总的来说,struct 更适合看成是一个数据结构的实现体,class 更适合看成是一个对象的实现体。
区别
默认的继承访问权限。struct 是 public 的,class 是 private 的。 struct 作为数据结构的实现体,它默认的数据访问控制是 public 的,而 class 作为对象的实现体,它默认的成员变量访问控制是 private 的。
联合(union)是一种节省空间的特殊的类,一个 union 可以有多个数据成员,但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点:
union 使用
#include<iostream>
union UnionTest
UnionTest() : i(10) ;
int i;
double d;
;
static union
int i;
double d;
;
int main()
UnionTest u;
union
int i;
double d;
;
std::cout << u.i << std::endl; // 输出 UnionTest 联合的 10
::i = 20;
std::cout << ::i << std::endl; // 输出全局静态匿名联合的 20
i = 30;
std::cout << i << std::endl; // 输出局部匿名联合的 30
return 0;
C 实现 C++ 类C 实现 C++ 的面向对象特性(封装、继承、多态)
explicit(显式)关键字[Can you write object-oriented code in C? closed]
explicit 使用
struct A
A(int)
operator bool() const return true;
;
struct B
explicit B(int)
explicit operator bool() const return true;
;
void doA(A a)
void doB(B b)
int main()
A a1(1); // OK:直接初始化
A a2 = 1; // OK:复制初始化
A a3 1 ; // OK:直接列表初始化
A a4 = 1 ; // OK:复制列表初始化
A a5 = (A)1; // OK:允许 static_cast 的显式转换
doA(1); // OK:允许从 int 到 A 的隐式转换
if (a1); // OK:使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
bool a6(a1); // OK:使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
bool a7 = a1; // OK:使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
bool a8 = static_cast<bool>(a1); // OK :static_cast 进行直接初始化
B b1(1); // OK:直接初始化
B b2 = 1; // 错误:被 explicit 修饰构造函数的对象不可以复制初始化
B b3 1 ; // OK:直接列表初始化
B b4 = 1 ; // 错误:被 explicit 修饰构造函数的对象不可以复制列表初始化
B b5 = (B)1; // OK:允许 static_cast 的显式转换
doB(1); // 错误:被 explicit 修饰构造函数的对象不可以从 int 到 B 的隐式转换
if (b1); // OK:被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
bool b6(b1); // OK:被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
bool b7 = b1; // 错误:被 explicit 修饰转换函数 B::operator bool() 的对象不可以隐式转换
bool b8 = static_cast<bool>(b1); // OK:static_cast 进行直接初始化
return 0;
friend 友元类和友元函数using 声明
一条 using 声明
语句一次只引入命名空间的一个成员。它使得我们可以清楚知道程序中所引用的到底是哪个名字。如:
using namespace_name::name;
构造函数的 using 声明
在 C++11 中,派生类能够重用其直接基类定义的构造函数。
class Derived : Base
public:
using Base::Base;
/* ... */
;
如上 using 声明,对于基类的每个构造函数,编译器都生成一个与之对应(形参列表完全相同)的派生类构造函数。生成如下类型构造函数:
Derived(parms) : Base(args)
using 指示
using 指示
使得某个特定命名空间中所有名字都可见,这样我们就无需再为它们添加任何前缀限定符了。如:
using namespace_name name;
尽量少使用 using 指示
污染命名空间
一般说来,使用 using 命令比使用 using 编译命令更安全,这是由于它只导入了指定的名称。如果该名称与局部名称发生冲突,编译器将发出指示。using编译命令导入所有的名称,包括可能并不需要的名称。如果与局部名称发生冲突,则局部名称将覆盖名称空间版本,而编译器并不会发出警告。另外,名称空间的开放性意味着名称空间的名称可能分散在多个地方,这使得难以准确知道添加了哪些名称。
using 使用
尽量少使用 using 指示
using namespace std;
应该多使用 using 声明
int x;
std::cin >> x ;
std::cout << x << std::endl;
或者
using std::cin;
using std::cout;
using std::endl;
int x;
cin >> x;
cout << x << endl;
:: 范围解析运算符分类
全局作用域符( ::name
):用于类型名称(类、类成员、成员函数、变量等)前,表示作用域为全局命名空间类作用域符( class::name
):用于表示指定类型的作用域范围是具体某个类的命名空间作用域符( namespace::name
):用于表示指定类型的作用域范围是具体某个命名空间的
:: 使用
int count = 11; // 全局(::)的 count
class A
public:
static int count; // 类 A 的 count(A::count)
;
int A::count = 21;
void fun()
int count = 31; // 初始化局部的 count 为 31
count = 32; // 设置局部的 count 的值为 32
int main()
::count = 12; // 测试 1:设置全局的 count 的值为 12
A::count = 22; // 测试 2:设置类 A 的 count 为 22
fun(); // 测试 3
return 0;
enum 枚举类型限定作用域的枚举类型
enum class open_modes input, output, append ;
不限定作用域的枚举类型
enum color red, yellow, green ;
enum floatPrec = 6, doublePrec = 10 ;
decltypedecltype 关键字用于检查实体的声明类型或表达式的类型及值分类。语法:
decltype ( expression )
decltype 使用
// 尾置返回允许我们在参数列表之后声明返回类型
template <typename It>
auto fcn(It beg, It end) -> decltype(*beg)
// 处理序列
return *beg; // 返回序列中一个元素的引用
// 为了使用模板参数成员,必须用 typename
template <typename It>
auto fcn2(It beg, It end) -> typename remove_reference<decltype(*beg)>::type
// 处理序列
return *beg; // 返回序列中一个元素的拷贝
引用左值引用
常规引用,一般表示对象的身份。
右值引用
右值引用就是必须绑定到右值(一个临时对象、将要销毁的对象)的引用,一般表示对象的值。
右值引用可实现转移语义(Move Sementics)和精确传递(Perfect Forwarding),它的主要目的有两个方面:
引用折叠
X& &
、X& &&
、X&& &
可折叠成 X&
X&& &&
可折叠成 X&&
好处
常量成员,因为常量只能初始化不能赋值,所以必须放在初始化列表里面 引用类型,引用必须在定义的时候初始化,并且不能重新赋值,所以也要写在初始化列表里面 没有默认构造函数的类类型,因为使用初始化列表可以不必调用默认构造函数来初始化
用花括号初始化器列表初始化一个对象,其中对应构造函数接受一个 std::initializer_list
参数.
initializer_list 使用
#include <iostream>
#include <vector>
#include <initializer_list>
template <class T>
struct S
std::vector<T> v;
S(std::initializer_list<T> l) : v(l)
std::cout << "constructed with a " << l.size() << "-element list\\n";
void append(std::initializer_list<T> l)
v.insert(v.end(), l.begin(), l.end());
std::pair<const T*, std::size_t> c_arr() const
return &v[0], v.size(); // 在 return 语句中复制列表初始化
// 这不使用 std::initializer_list
;
template <typename T>
void templated_fn(T)
int main()
S<int> s = 1, 2, 3, 4, 5; // 复制初始化
s.append(6, 7, 8); // 函数调用中的列表初始化
std::cout << "The vector size is now " << s.c_arr().second << " ints:\\n";
for (auto n : s.v)
std::cout << n << \' \';
std::cout << \'\\n\';
std::cout << "Range-for over brace-init-list: \\n";
for (int x : -1, -2, -3) // auto 的规则令此带范围 for 工作
std::cout << x << \' \';
std::cout << \'\\n\';
auto al = 10, 11, 12; // auto 的特殊规则
std::cout << "The list bound to auto has size() = " << al.size() << \'\\n\';
// templated_fn(1, 2, 3); // 编译错误!“ 1, 2, 3 ”不是表达式,
// 它无类型,故 T 无法推导
templated_fn<std::initializer_list<int>>(1, 2, 3); // OK
templated_fn<std::vector<int>>(1, 2, 3); // 也 OK
面向对象面向对象程序设计(Object-oriented programming,OOP)是种具有对象概念的程序编程典范,同时也是一种程序开发的抽象方针。
面向对象三大特征 —— 封装、继承、多态
封装把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。关键字:public, protected, private。不写默认为 private。
public
成员:可以被任意实体访问protected
成员:只允许被子类及本类的成员函数访问private
成员:只允许被本类的成员函数、友元类或友元函数访问重载多态(Ad-hoc Polymorphism,编译期):函数重载、运算符重载 子类型多态(Subtype Polymorphism,运行期):虚函数 参数多态性(Parametric Polymorphism,编译期):类模板、函数模板 强制多态(Coercion Polymorphism,编译期/运行期):基本类型转换、自定义类型转换
The Four Polymorphisms in C++
静态多态(编译期/早绑定)
函数重载
class A
public:
void do(int a);
void do(int a, int b);
;
动态多态(运行期期/晚绑定)
注意:
动态多态使用
class Shape // 形状类
public:
virtual double calcArea()
...
virtual ~Shape();
;
class Circle : public Shape // 圆形类
public:
virtual double calcArea();
...
;
class Rect : public Shape // 矩形类
public:
virtual double calcArea();
...
;
int main()
Shape * shape1 = new Circle(4.0);
Shape * shape2 = new Rect(5.0, 6.0);
shape1->calcArea(); // 调用圆形类里面的方法
shape2->calcArea(); // 调用矩形类里面的方法
delete shape1;
shape1 = nullptr;
delete shape2;
shape2 = nullptr;
return 0;
虚析构函数虚析构函数是为了解决基类的指针指向派生类对象,并用基类的指针删除派生类对象。
虚析构函数使用
class Shape
public:
Shape(); // 构造函数不能是虚函数
virtual double calcArea();
virtual ~Shape(); // 虚析构函数
;
class Circle : public Shape // 圆形类
public:
virtual double calcArea();
...
;
int main()
Shape * shape1 = new Circle(4.0);
shape1->calcArea();
delete shape1; // 因为Shape有虚析构函数,所以delete释放内存时,先调用子类析构函数,再调用基类析构函数,防止内存泄漏。
shape1 = NULL;
return 0;
纯虚函数纯虚函数是一种特殊的虚函数,在基类中不能对虚函数给出有意义的实现,而把它声明为纯虚函数,它的实现留给该基类的派生类去做。
virtual int A() = 0;
虚函数、纯虚函数虚函数指针、虚函数表CSDN . C++ 中的虚函数、纯虚函数区别和联系
.rodata section
,见:目标文件存储结构),存放虚函数指针,如果派生类实现了基类的某个虚函数,则在虚表中覆盖原本基类的那个虚函数指针,在编译时根据类的声明创建。虚继承C++中的虚函数(表)实现机制以及用C语言对其进行的模拟实现
虚继承用于解决多继承条件下的菱形继承问题(浪费存储空间、存在二义性)。
底层实现原理与编译器相关,一般通过虚基类指针和虚基类表实现,每个虚继承的子类都有一个虚基类指针(占用一个指针的存储空间,4字节)和虚基类表(不占用类对象的存储空间)(需要强调的是,虚基类依旧会在子类里面存在拷贝,只是仅仅最多存在一份而已,并不是不在子类里面了);当虚继承的子类被当做父类继承时,虚基类指针也会被继承。
实际上,vbptr 指的是虚基类表指针(virtual base table pointer),该指针指向了一个虚基类表(virtual table),虚表中记录了虚基类与本类的偏移地址;通过偏移地址,这样就找到了虚基类成员,而虚继承也不用像普通多继承那样维持着公共基类(虚基类)的两份同样的拷贝,节省了存储空间。
虚继承、虚函数malloc、calloc、realloc、alloca
malloc:申请指定字节数的内存。申请到的内存中的初始值不确定。 calloc:为指定长度的对象,分配能容纳其指定个数的内存。申请到的内存的每一位(bit)都初始化为 0。 realloc:更改以前分配的内存长度(增加或减少)。当增加长度时,可能需将以前分配区的内容移到另一个足够大的区域,而新增区域内的初始值则不确定。 alloca:在栈上申请内存。程序在出栈的时候,会自动释放内存。但是需要注意的是,alloca 不具可移植性, 而且在没有传统堆栈的机器上很难实现。alloca 不宜使用在必须广泛移植的程序中。C99 中支持变长数组 (VLA),可以用来替代 alloca。
malloc、free
用于分配、释放内存
malloc、free 使用
申请内存,确认是否申请成功
char *str = (char*) malloc(100);
assert(str != nullptr);
释放内存后指针置空
free(p);
p = nullptr;
new、delete
new / new[]:完成两件事,先底层调用 malloc 分配了内存,然后调用构造函数(创建对象)。 delete/delete[]:也完成两件事,先调用析构函数(清理资源),然后底层调用 free 释放空间。 new 在申请内存时会自动计算所需字节数,而 malloc 则需我们自己输入申请内存空间的字节数。
new、delete 使用
申请内存,确认是否申请成功
int main()
T* t = new T(); // 先内存分配 ,再构造函数
delete t; // 先析构函数,再内存释放
return 0;
定位 new
定位 new(placement new)允许我们向 new 传递额外的地址参数,从而在预先指定的内存区域创建对象。
new (place_address) type
new (place_address) type (initializers)
new (place_address) type [size]
new (place_address) type [size] braced initializer list
place_address
是个指针initializers
提供一个(可能为空的)以逗号分隔的初始值列表Is it legal (and moral) for a member function to say delete this?
合法,但:
必须保证 this 对象是通过 new
(不是new[]
、不是 placement new、不是栈上、不是全局、不是其他对象成员)分配的必须保证调用 delete this
的成员函数是最后一个调用 this 的成员函数必须保证成员函数的 delete this
后面没有调用 this 了必须保证 delete this
后没有人使用了
如何定义一个只能在堆上(栈上)生成对象的类?
只能在堆上
方法:将析构函数设置为私有
原因:C++ 是静态绑定语言,编译器管理栈上对象的生命周期,编译器在为类对象分配栈空间时,会先检查类的析构函数的访问性。若析构函数不可访问,则不能在栈上创建对象。
只能在栈上
方法:将 new 和 delete 重载为私有
原因:在堆上生成对象,使用 new 关键词操作,其过程分为两阶段:第一阶段,使用 new 在堆上寻找可用内存,分配给对象;第二阶段,调用构造函数生成对象。将 new 操作设置为私有,那么第一阶段就无法完成,就不能够在堆上生成对象。
智能指针C++ 标准库(STL)中
头文件:#include <memory>
C++ 98
std::auto_ptr<std::string> ps (new std::string(str));
C++ 11
shared_ptr unique_ptr weak_ptr auto_ptr(被 C++11 弃用)
shared_ptr
多个智能指针可以共享同一个对象,对象的最末一个拥有着有责任销毁对象,并清理与该对象相关的所有资源。
weak_ptr
weak_ptr 允许你共享但不拥有某对象,一旦最末一个拥有该对象的智能指针失去了所有权,任何 weak_ptr 都会自动成空(empty)。因此,在 default 和 copy 构造函数之外,weak_ptr 只提供 “接受一个 shared_ptr” 的构造函数。
unique_ptr
unique_ptr 是 C++11 才开始提供的类型,是一种在异常时可以帮助避免资源泄漏的智能指针。采用独占式拥有,意味着可以确保一个对象和其相应的资源同一时间只被一个 pointer 拥有。一旦拥有着被销毁或编程 empty,或开始拥有另一个对象,先前拥有的那个对象就会被销毁,其任何相应资源亦会被释放。
auto_ptr
被 c++11 弃用,原因是缺乏语言特性如 “针对构造和赋值” 的 std::move
语义,以及其他瑕疵。
auto_ptr 与 unique_ptr 比较
move
语义;delete
),unique_ptr 可以管理数组(析构调用 delete[]
);MSDN . 强制转换运算符
static_cast
向上转换是一种隐式转换。
dynamic_cast
const_cast
reinterpret_cast
char*
到 int*
或 One_class*
到 Unrelated_class*
之类的转换,但其本身并不安全)bad_cast
bad_cast 使用
try
Circle& ref_circle = dynamic_cast<Circle&>(ref_shape);
catch (bad_cast b)
cout << "Caught: " << b.what();
运行时类型信息 (RTTI)dynamic_cast
typeid
type_info
typeinfo
typeid、type_info 使用
#include <iostream>
using namespace std;
class Flyable  2000字读懂Java的来源
title: Java的来源
blog: CSDN
data: Java学习路线及视频
1.Java市场
截至2020-03: Java的市场份额为17.78%
2. Java语言简介
- 是SUN(Stanford University Network,斯坦福大学网络公司 ) 1995年推出的一 门高级编程语言。
- 是一种面向Internet的编程语言。Java一开始富有吸引力是因为Java程序可以 在Web浏览器中运行。这些Java程序被称为Java小程序(applet)。applet使 用现代的图形用户界面与Web用户进行交互。 applet内嵌在HTML代码中。
- 随着Java技术在web方面的不断成熟,已经成为Web应用程序的首选开发语言。
后台开发语言:Java、PHP、Python、Go、Node.js
3. Java发展史
4. Java技术体系平台
5. Java在各领域的应用
-
从Java的应用领域来分,Java语言的应用方向主要表现在以下几个方面:
-
企业级应用:主要指复杂的大企业的软件系统、各种类型的网站。Java的安全机制以及它的跨平台的优势,使它在分布式系统领域开发中有广泛应用。应用领域包括金融、电信、交通、电子商务等。
-
Android平台应用:Android应用程序使用Java语言编写。Android开发水平的高低很大程度上取决于Java语言核心能力是否扎实。
-
大数据平台开发:各类框架有Hadoop,spark,storm,flink等,就这类技术生态圈来讲,还有各种中间件如flume,kafka,sqoop等等 ,这些框架以及工具大多数是用Java编写而成,但提供诸如Java,scala,Python,R等各种语言API供编程。
-
移动领域应用:主要表现在消费和嵌入式领域,是指在各种小型设备上的应用,包括手机、PDA、机顶盒、汽车通信设备等。
6.Java语言的诞生
java之父James Gosling团队在开发”Green”项目时,发现C缺少垃圾回收系统,还有可移植的安全性、分布程序设计和多线程功能。最后,他们想要一种易于移植到各种设备上的平台。
Java确实是从C语言和C++语言继承了许多成份,甚至可以将Java看成是类C语言发展和衍生的产物。比如Java语言的变量声明,操作符形式,参数传递,流程控制等方面和C语言、C++语言完全相同。但同时,Java是一个纯粹的面向对象的程序设计语言,它继承了C++语言面向对象技术的核心。Java舍弃了C语言中容易引起错误的指针(以引用取代)、运算符重载(operator overloading)、多重继承(以接口取代)等特性,增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间。JDK1.5又引入了泛型编程(GenericProgramming)、类型安全的枚举、不定长参数和自动装/拆箱
7.Java语言的主要特性
- Java语言是易学的
- Java语言的语法与C语言和C++语言很接近,使得大多数程序员很容易学习和使用Java
- Java语言是强制面向对象的
- Java语言提供类、接口和继承等原语,为了简单起见,只支持类之间的单继承,但支持接口之间的多继承,并支持类与接口之间的实现机制关键字为implements。
- Java语言是分布式的
- Java语言支持Internet应用的开发,在基本的Java应用编程接口中有一个网络应用编程接口(java net),它提供了用于网络应用编程的类库,包括URL、URLConnection、Socket、ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。
- Java语言是健壮的
- Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。
- Java语言是安全的
- Java通常被用在网络环境中,为此,Java提供了一个安全机制以防恶意代码的攻击。如:安全防范机制(类ClassLoader),如分配不同的名字空间以防替代本地的同名类、字节代码检查。
- Java语言是体系结构中立的
- Java程序(后缀为java的文件)在Java平台上被编译为体系结构中立的字节码格式(后缀为class的文件),然后可以在实现这个Java平台的任何系统中运行。
- Java语言是解释型的
- Java程序在Java平台上被编译为字节码格式,然后可以在实现这个Java平台的任何系统的解释器中运行
- Java是性能略高的
- 与那些解释型的高级脚本语言相比,Java的性能还是较优的
- Java语言是原生支持多线程的
- 在Java语言中,线程是一种特殊的对象,它必须由Thread类或其子(孙)类来创建。
8.Java程序运行机制及运行过程
Java语言的特点
- 面向对象
- 两个基本概念:类、对象
- 三大特性:封装、继承、多态
- 健壮性
- 吸收了C/C++语言的优点,但去掉了其影响程序健壮性的部分(如指针、内存的申请与释放等),提供了一个相对安全的内存管理和访问机制
- 跨平台性
- 通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run Anywhere”
因为有了JVM,同一个Java 程序在三个不同的操作系统中都可以执行。这样就实现了Java 程序的跨平台性。
Java两种核心机制
- Java虚拟机
- JVM是一个虚拟的计算机,具有指令集并使用不同的存储区域。负责执行指令,管理数据、内存、寄存器。
- 对于不同的平台,有不同的虚拟机。
- 只有某平台提供了对应的java虚拟机,java程序才可在此平台运行
- Java虚拟机机制屏蔽了底层运行平台的差别,实现了“一次编译,到处运行”
- 垃圾回收
- 不再使用的内存空间应回收—— 垃圾回收。
- 在C/C++等语言中,由程序员负责回收无用内存。
- Java 语言消除了程序员回收无用内存空间的责任:它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时,检查并释放那些可被释放的存储空间。
- 垃圾回收在Java程序运行过程中自动进行,程序员无法精确控制和干预。
- Java程序还会出现内存泄漏和内存溢出问题吗?Yes!
9.常用的Java开发工具
-
文本编辑工具
-
Java集成开发环境
10.结语
- 2020-3-23: 3000字编程入门--附带Java学习路线及视频
以上是关于五万字读懂c++的主要内容,如果未能解决你的问题,请参考以下文章