从 c 到 c++ , c++基础-CSDN博客

本文链接：https://blog.csdn.net/weixin_43819521/article/details/126918613

#include <iostream>  //引入标准输入输出流

using namespace std;   //使用标准名词空间

一、引用 reference

1.1 基础引用

可以改变引用的变量值，但是不能再次成为其他变量的引用
声明引用时，必须同时对其初始化
声明引用时，初始化的值不能为NULL
可以将引用的地址赋值给指针，指针指向原来的变量
可以建立指针的引用
- ```
int* p = &a;
int*& q = p;
```

1.2 const引用

声明引用时，初始化的值可以是纯数值，此时需要使用const修饰，常引用
- ```
const int& a = 12;       //值不能改变
```

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 函数重载

c++ 中允许同一个函数名定义多个函数，这种用法就是函数重载
重载的函数通过参数进行区分，与返回值无关，函数必须参数个数或类型不同
构造函数与成员函数也可以重载，析构函数不能重载

4.3 函数的默认参数/缺省参数

c++ 允许给函数的参数设定默认值
调用函数时，如果传入参数，传入的参数会覆盖默认值
函数声明和定义分离时，默认值只能出现一次
默认值设定遵循（向右原则），默认值右边的参数必须有默认值

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 静态成员函数

静态成员函数可以调用其他静态成员，但不能调用本类的非静态成员
静态成员函数没有this指针，而类中非静态成员调用是通过this完成的
非静态的成员可以访问静态成员

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的成员变量，但是不能修改其数值
不能调用非const的成员函数

建议成员函数不修改属性值的，都应设为const，例如getter

void getter() const;  //类内声明

int Test::get_a() const  //类外定义，需要加上const
{
    return a;
}

11.2 常量对象

const可以修饰对象，表示该对象为常量对象。

常量对象的特点有：

常量对象中任何成员变量都不能被修改
常量对象不能调用任何非 const 的成员函数

11.3 常成员变量

常成员变量的特点是：

数值在运行期不能被修改
数值在编译期可以被修改
必须赋予初始值，可以在声明后立刻赋值，也可以使用构造初始化列表赋值。

二者都使用时，可以发现构造初始化列表的赋值生效，其原因是构造初始化列表与声明都是在编译期间确定的，构造初始化列表编译顺序靠后。

const修饰的局部变量数值不可变