#include <iostream> //引入标准输入输出流
using namespace std; //使用标准名词空间
一、引用 reference
1.1 基础引用
1.2 const引用
-
声明引用时，初始化的值可以是纯数值，此时需要使用const修饰，常引用
-
int a = 100;
const int &b = a; // b 的值会随a的改变而改变 ，但不能对b更改
a++;
-
double x = 1.2;
const int& y = x; //只能使用const 引用接收
1.3 引用作为参数传递
- 当大型的对象作为参数传递时，使用引用参数可以使用传递效率变高，
- 相对于指针跟简洁
- 能定义const , 尽量 const
void swap(int& a, int& b） // 直接可以修改原变量
{
a ^= b;
b ^= a;
a ^= b;
}
swap(a,b); //调用
二、c++ 中的赋值
int c(a); //相当于 int c = a;
int c{a}; //c11 标准
三、string 类
????????string 使用的编码时ACSII , 不支持中文
string str1,str2;
str1 = "acb"; // 赋值不要使用中文
str2 = "acb" + "abc"; // 追加
int a = str1.size(); // 计算字符串长度 或者 str.length();
if(str1 == str2){ // 比较
cout << "相同" << endl;
}
3.1?取出字符串
char c = str[1]; //当范围越界时，[] 直接返回‘\0’，程序不会终止
char c = str.at(0); //越界，会报错，程序会终止
3.2 遍历? ? ? ?
?????????string 的遍历支持若干方式： for 循环、for-each循环（c++11）、迭代器
for(char i: str) //for-each循环
{
cout << i << " ";
}
int a[3] = {1,2,3};
for(int x: a)
{
cout << x << endl;
}
3.3 std::string类的相关函数
str.empty(); // 判断是否为空
string str(str1); // 拷贝构造函数
string str("ABC",2); // char* 从前往后，保留的字符数量
string str(str1,2); // string 从前往后，不保留字符数量
string str(5,'z'); // 字符数量 字符内容char // zzzzz
swap(str1,str2); // 交换内容 任意类型
str.append("abc").append("BAC"); // 追加，支持链式调用
str.push_back('*'); // 向后追加单个字符
str.insert(0,"66"); // 在指定位置插入字符串
str.erase(4,10); // 从第五个位置开始，抹除10个字符
str.clear(); // 清空
// 类型转换 将 string → char* 【正确做法】从临时指针中拷贝内容出来
char ca[20];
strcpy(ca,str.c_str());
四、函数
4.1 内联函数
-
取代宏定义的函数 -
关键字 inline 放在函数定义的前面 ， 不是声明 -
编译时，将函数体在调用的地方替换，可以消除普通函数在运行期的额外开销 -
一般将代码长度较小（5行以内）且频繁使用的函数定义为内联函数 -
成员函数默认时内联函数
4.2 函数重载
4.3?函数的默认参数/缺省参数
void fun(int a, int b = 2, int c = 3)
????????默认参数和函数重载可能会出现二异性问题
void fun(int b)
{
b--;
cout << b << endl;
}
void fun(int s,string s1 = "abc")
{
cout << s << " " << s1 << endl;
}
fun(12); //调用出错 ambiguous 、 ambiguity
4.4 哑元函数
????????函数只有参数类型，没有参数名 ； 调用时，仍然需要传递参数
哑元函数的主要用途：
-
表达参数列表匹配更加严格 -
保持函数的向前兼容性 -
区分重载的同名函数
五、类与对象
类：抽象的 规定同一类对象拥有的行为和属性
对象 ：具体的 按照类的概念创建出来的实体
5.1 类的定义
class MobilePhone
{
public:
string brand;
void play_game(); //声明
};
void MobilePhone::play_game() //定义
{
cout << "TiMi" << endl;
}
5.1.1权限
| public | protected | private |
|---|
| 成员函数 | 可访问 | 可访问 | 可访问 | | 对象 | 可访问 | 不可访问 | 不可访问 | | 子类的函数 | 可访问 | 可访问 | 不可访问 | | 友元函数 | 可访问 | 可访问 | 可访问 |
5.2 对象实例化
c++ 两种创建对象的方式
MobilePhone* mb1 = new MobilePhone; //申请空间
mb1->play_music();
delete mb1; //释放空间
5.3 封装
????????类实现了数据的隐藏与封装，类中成员变量一般定义为私有成员，通过公开的接口才能进行读写。
提升数据安全性
读取属性：getter
写入属性：setter
class Value
{
private:
int value = 10;
public:
int get_value() // getter
{
return value;
}
void set_value(int v) // setter
{
value = v;
}
};
5.4 构造函数
5.4.1构造函数基本使用
????????无返回值，函数名和类名一致，初始化成员
????????编译器会自动添加空的构造函数，
class MobilePhone
{
private:
string model;
int weight;
public:
string brand;
void show();
MobilePhone();
MobilePhone(string m, int w);
};
void MobilePhone::show()
{
cout << model << " " << weight << endl;
}
MobilePhone::MobilePhone()
{
model = "mi";
weight = 122;
}
MobilePhone::MobilePhone(string m, int w = 199) //构造函数的重载
{
model = m;
weight = w;
}
int main()
{
MobilePhone mb1; //默认参数
mb1.show();
MobilePhone mb2("apple",201); //设置参数
mb2.show();
return 0;
}
5.4.2?构造初始化列表
关于构造初始化列表，需要注意以下几点：
????????另外，属性值也可以直接赋值，
public:
MobilePhone(string m , string b, int w)
:model(m),brand(b),weight(w){}
// 设置属性的默认值
private:
string brand = "山寨";
string model = "8848";
int weight = 188;
5.4.3 拷贝构造函数
????????当成员变量出现指针类型时，默认的拷贝构造函数是基于赋值操作的，因此在拷贝的过程中，会出现指针的拷贝，会造成多个对象的属性指向同一个内存区域的问题，这样的现象不符合面向对象的设计规范。
浅拷贝
class Dog
{
private:
char* name; // 故意使用char*
public:
Dog(char* n)
{
name = n;
}
// 编译器自动添加下面的拷贝构造函数
Dog(const Dog& d)
{
name = d.name; // 指针的拷贝！
}
};
深拷贝
????????默认的拷贝是浅拷贝，当属性出现指针类型，应该手写一个深拷贝构造函数。
public:
Dog(char* n)
{
// 创建堆内存对象
name = new char[20];
// 数据复制
strcpy(name,n);
}
Dog(const Dog& d)
{
// 创建堆内存对象
name = new char[20];
// 数据复制
strcpy(name,d.name);
}
5.5 隐式调用构造函数
string s1;
Test t2 = s1;? ??? //隐式调用? ? ?//explicit 关键字可屏蔽隐式调用
六、析构函数
| 构造函数 | 析构函数 |
|---|
| 对象创建时调用 | 销毁对象时调用 | | 手动调用 | 自动调用 | | 可以有参数，可以重载 | 不能有参数，不能重载 | | 名称： 类名 | 名称：~类名 |
~Dog()
{
delete name; //释放拷贝构造函数的变量
}
七、作用域限定符 ::
7.1 名字空间
????????标准名称空间 std , 例：std::cout, std::cin , std::endl
namespace my_space{ //自定义名字空间
int a = 1;
}
using namespace my_space;
cout << a << endl;
7.2 类内声明，类外定义
? ? ? ? 见类定义
八、this 指针
-
一个特殊的指针，保存对象的地址，指向类外的对象 -
this 关键字只能在类内使用
private:
string name;
public:
Teacher(string name)
{
this->name = name; //区分重名的成员变量和局部变量
}
8.1 *this 表示引用对象
class Value
{
private:
int value = 10;
public:
Value& add(int i) //表示支持链式调用
{
value += i;
return *this;
}
int get_value()
{
return value;
}
};
Value v;
cout << v.add(5).add(-3).add(6).get_value << endl;
cout << &v.add(5).add(-3).add(6) << " " << &v << endl; //结果一致
九、static 关键字
9.1静态局部变量
class Value
{
public:
void _static()
{
static int a = 1; //第一次调用会创建，不会销毁，只会创建一次
cout << a++ << " " << &a << endl;
}
void _local()
{
int a = 1; //每次调用都会创建，巧合在同一空间创建
cout << a++ << " " << &a << endl;
}
};
9.2 静态成员变量
????????静态成员变量必须初始化
class Test
{
public:
static int a; //类内声明， 不能使用static int a = 1;
};
int Test::a = 1; //类外初始化
cout << Test::a << " " << &Test::a << endl; // 1 0x408004
9.3 静态成员函数
class Test
{
public:
static void test1();
}
void Test::test1() //类外定义
{
cout << " " << endl;
}
Test::test1(); //使用类名直接调用
十、单例模式
????????设计模式是一套被反复使用的、多数人知晓的、经过分类的代码设计经验总结。
class Singleton //基于指针的单例模式，只能创建一个对象
{
//屏蔽构造函数
private:
Singleton(){}
Singleton(const Singleton&){}
~Singleton(){}
static Singleton* instance;
public:
static Singleton* get_instance() //创建实例
{
if(instance == NULL)
instance = new Singleton;
return instance;
}
static void delete_instance() //释放实例
{
if(instance != NULL)
{
delete instance;
instance = NULL; //复位，重置
}
}
};
Singleton* Singleton::instance = NULL; //类外初始化
int main()
{
Singleton* s1 = Singleton::get_instance();
cout << &s1 << endl;
return 0;
}
class Singleton //基于引用的单例模式
{
private:
// 屏蔽构造函数
Singleton(){}
Singleton(const Singleton&){}
~Singleton(){} // 析构函数
public:
static Singleton& get_instance()
{
// 静态局部变量，单实例对象会一直存在到程序结束
static Singleton instance;
return instance;
}
};
十一、const 关键字
????????应该是运行期常量或运行期只读，即const关键字在编译期并不生效。
11.1 常成员函数
????????const修饰成员函数，表示常成员函数，这样的函数特点是：
????????建议成员函数不修改属性值的，都应设为const，例如getter
void getter() const; //类内声明
int Test::get_a() const //类外定义，需要加上const
{
return a;
}
11.2 常量对象
????????const可以修饰对象，表示该对象为常量对象。
常量对象的特点有：
-
常量对象中任何成员变量都不能被修改 -
常量对象不能调用任何非 const 的成员函数
11.3 常成员变量
常成员变量的特点是：
????????二者都使用时，可以发现构造初始化列表的赋值生效，其原因是构造初始化列表与声明都是在编译期间确定的，构造初始化列表编译顺序靠后。
const修饰的局部变量数值不可变
|