C到C++快速过渡

空名_Noname

已于 2023-03-15 11:03:18 修改

阅读量356

点赞数

分类专栏： c++笔记文章标签： c++ c语言开发语言

于 2023-03-15 10:52:25 首次发布

本文链接：https://blog.csdn.net/qq_45764251/article/details/129548177

版权

c++笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

C++编译环境

编译源文件，生成二进制的目标文件(.obj)
- g++ -cfile.cpp ==> file.obj ; a.out(输出型文件)
  (UNIX下编译，win用DOS窗口进行此编译)
- g++ -std=c++17 -cfile.cpp -oprog ==> file.obj ; prog.out
  (用指定标准进行编译…prog:生成的文件的名字)
链接目标文件，生成可执行文件(.exe)
- g++ -o prog file1.obj file2.obj …

MinGW:g++的windows平台移植版本
Online C++ Compiler:(用谷歌搜索)在线编译平台

推荐使用IDB集成开发环境：CB(Code::Blocks);VS(Visual Studio)

C标准库的C++移植

C++中包含了C标准库的移植版本
C标准库的头文件 x.h 基本上变成了 cx

stdio.h => cstdio
math.h => cmath
string.h => cstring
…
也有例外：malloc.h就没变

条件编译

不是条件语句
#if 0 … #endif
#if 1 … #else … #endif
#if 1 … #elif … #elif … #endif

#表示预处理，处理完了再交给编译器编译
o舍1用

#ifdef xxx … #endif
#ifdef xxx … #else …#endif

ifdef表示如果前面宏定义了xxx即执行语句

C++标准输入/输出

名字空间

#include <iostream>
int main ()
{
    std::cout << "holle world";
    return 0;
}

C++看作一个数据流向外部设备输入/输出

包含头文件 iostream
cout是一个标准输出流对象，代表控制台窗口
<<是运算符，假如o是输出流对象，x是数据，即可 o << x

C++调用的库多，使用名字空间限定以防止名字冲突
就像现实中同名的情况：计算机::张伟机械::张伟

加上std::以标明
函数体前加上 using std::cout; 提前对cout进行说明
函数体前加上 using namespace std; 引入整个名字空间

#include <iostream>
using std::cout;
using namespace std;
int main(){...}

cout:标准输出流
<<输出符号
cin:标准输入流
>>输入符号

int a;   std::cin >> a;   std::cout << a;
//类似于
int a;   scanf("%d", &a);   printf("%d", a);

文件输入/输出流

#include <fstream>
using namespace std;
int main()
{
    ofstream oF("text.txt");
    oF << "hello world!" << endl;
    //创建文件并将字符串写入到文件
    ifstream iF("text.txt");
    string str;
    iF >> str;
    //找到文件并将字符串从文件中写到变量
    return 0;
}

头文件fstream
定义文件输入流 ifstream
定义文件输出流 ofstream

引用变量

引用变量是其他变量的别名
定义引用变量时必须指明引用的是哪一个变量

int a = 3;
int &r = a;

引用变量“从一而终”，一旦定义不能再定义

int &r = a;
int &r = b;(x)

引用变量和被引用的变量类型必须匹配

double a;
int &r = a;(x)

对引用变量的操作就是对被引用变量的操作

函数的形参

值形参：形参作为函数的局部变量有自己单独的内存块，当函数调用时，实参将值赋值给形参。对形参的改变不会影响实参
指针形参：传递地址，从地址层面由形参改变实参，事实上，是直接对实参进行了操作
引用形参：定义引用变量，从而引用实参，对引用形参的操作就是对实参的操作(C++特有)

void swap(int &a,int &b)
{
    int c;
    c = a;a = b;b = c;
}
int main()
{
    int a = 1, b = 2;
    swap(a,b);
}

函数的默认形参

函数的形参可以有默认值

void print(char ch,int n=1);

默认形参必须在非默认形参右边，即一律靠右

add(x, y=1, z=2);
add(x=1, y, z=2);(x)

函数重载

C++允许同一作用域内有同名的函数，只要他们的形参不同

int add(int x);
int add(double x);
可以同时存在

函数名和形参列表构造了函数签名
函数重载不能根据返回类型区分函数

int add(int x);
double add(int x);
这样不被允许

函数模板

通用模板：函数模板。也称为泛型算法

int add(int x,int y)
{
    return x+y;
}
double add(double x,double y)
{
    return x+y;
}

复制粘贴形成的，对于不同的情况要做不同的修改，不方便使用，所以C++对此有所改进

用template关键字增加一个模板头，将数据类型变成类型模板参数

template<typename T>
T add(T x, T y)
{
    return x+y;
}

T是模板头，这样定义的只是一个模板不是函数，运用时，将模板实例化，产生所需函数

int main()
{
    ...
    cout << add<int>(5, 3) << endl;
    cout << add<double>(5.3, 7.8) << endl;
    ...
}

这样就产生了所需的int add(int x,int y){…};和double add(double x,double y){…};
而且只要保证模板的正确性

模板参数可自动推断，部分数据类型，编译器可以自己推断，省略类型也是允许的

int main()
{
    ...
    cout << add(5, 3) << endl;
    cout << add(5.3, 7.8) << endl;
    ...
}//等价于上一段代码

用户定义类型string和vector

string

是一个用户定义类型，表示字符串

string s = “hello”, s2(“world”);(两种定义方法)

用成员访问运算符点 . 访问string类的成员

cout << s.size() << endl;
string s3 = s.substr(1, 3);
cout << s3 << endl;

用运算符对string对象进行运算，如+、[]

+号进行字符串的拼接

string s = “123” + “456”;

[]号类似于数组，对字符串进行取值

char s0 = s[4];

vector

C里一般的数组是静态数组，内存一旦分配即大小固定，而C++提供了新的一种类似于数组的数据类型vector

与上述的string有些类似，类似的原理，类似的对成员操作
向量，类似于数组，但可以动态增长。头文件
是一个类模板，实例化产生一个类，如:vector产生一个数据元素是int的vector类(向量)
同样，可以通过vector类对象去访问其成员，如成员函数

#include <iostream>
#include <vector>
using namespace std;
int main()
{
	vector<int> v = {1, 2, 3};        //定义一个int类v
	v.push_back(4);                   //在末尾加上一个元素4
	for (int i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	v.pop_back();                     //删去最后一个元素
	return 0;
}

动态内存分配

静态变量存放在内存的堆栈区，而内存里有堆存储区，由所有程序共享，动态分配内存即向堆存储区申请内存

malloc/calloc：C里常用的一种内存分配函数
new：C++新增的一种内存分配函数

int *p = new int;//向内存申请一块int大小的内存
int *p = new int[n];//向内存申请n块int大小的内存

申请的内存无用后记得要释放

free：C里常用的一种内存释放函数
delete：C++新增的一种内存释放函数

delete p;

#include <iostream>
using namespace std;
int main()
{
	int* p = new int;
	*p = 1;
	cout << *p << endl;
	delete p;
	p = new int[4];
	for (int i = 0; i < 4; i++) 	p[i] = i;
	delete p;
	return 0;
}

类和对象(重点)

(具体可见另两篇关于类的C++笔记)

传统的过程式编程：变量(对象)就是一些存储数据的内存块，而过程(函数)对这些数据进行处理

将一个问题分解成很多问题，再分解成更多的小问题
缺点也有很多：
- 对于一些数据(如：全局变量)就不够安全(其他函数都可以调用)
- 维护起来比较麻烦，修改了一处，可能多处调用，多处有联系，而多处要改动，带来了很多困难
C语言使用此方法，一个程序由函数构成，而函数由一系列指令语句构成

面向对象编程：程序是由不同种类的许多对象相互协作完成的。对象之间通过发送/接受消息来写作完成各种任务。由这些对象构成的程序也称为“对象式系统”

每个对象的数据(属性)都是隐藏起来的，其他对象不能直接访问
面向对象编程的核心工作：有哪些对象？对象属于哪种类型？不同类型间有什么关系？

例如人驾驶车：涉及对象“人”和“车”
从具有共同特征的许多对象抽象出某种概念，如“人”、“车”：

人：眼、耳、鼻、嘴巴、手、脚…哭笑喊唱、打架、游泳、驾驶…
车：车门、门、引擎、车轮、方向盘、座位…加速、刹车、熄火…

以上即是两个对象的概念(属性)，也可以构造出具体的对象：
人=>张三，车=>某辆车

面向对编程要分析不同概念之间的不同关系:包含、派生…
不同的思考方式：面向对象编程VS过程式编程