C++笔记

最新推荐文章于 2024-09-04 17:18:01 发布
最新推荐文章于 2024-09-04 17:18:01 发布
阅读量187 收藏
点赞数
分类专栏： 计算机编程 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46220854/article/details/113104271
版权
这篇笔记详细介绍了C++的面向对象编程（OOP）和泛型编程（GP）概念，涵盖了C++的新特性、类与对象、函数模板、运算符重载、继承与多态等方面，旨在帮助读者深入理解C++编程。
摘要由CSDN通过智能技术生成

这是我C++的学习笔记

在C的基础上，首先对面向过程编程（Procedure Oriented Programming）中的新特性作一些补充。本笔记主要着重于面向对象编程（Object Oriented Programming）（侧重于数据）和泛型编程（Generic Programming）（侧重于工具）。

一、C++新特新补充

  1. 头文件声明的变化
    头文件声明的变化以及对.h头文件的继承
    头文件的使用会影响对名称空间的使用。
  2. 名称空间namespace以及编译指令using
    名称空间相当于对名称（变量名称，函数名称，操作名称，etc.）再作一次封装，以应对不同厂商的不同函数/操作/变量撞名时的情况。可通过using指令全空间调用，也可通过“::”作用域运算符单独调用。
    对于未命名的名称空间，作用域为声明点到该区末尾。
    C++标准语言库为std。
using namespace space_name;
//全空间调用名称空间space_name，使能该空间定义的全部名称
//可放在函数体内部或外部，使在本函数或本文本中所有函数可用

using space_name::space_mem_name;
//仅使能space_name中的space_mem_name

...space_name::space_mem_name...
//抑或在调用时再通过::声明（调用多时会比较麻烦）
  1. cin和cout的使用
    cout的使用
    cout的使用
    \n和endl在cout中的使用。
    在cout中，亦可对输出流进行格式化。
    cout可通过多个<<进行拼接。
    cin的使用
type_name stream_target;
cin >> stream_target;
//将键盘输入流输入到stream_target对象中
//输入流将被自动转换为type_name类型

在这里插入图片描述

  1. bool类型
    布尔变量只有ture（非零值）和false（零值）两种值，赋值后变量会被自动转换。
bool para_1 = 100;	//para_1 assigned true
bool para_2 = -100;	//para_2 assigned true
bool para_3 = 0;	//para_3 assigned false
  1. 关于强制类型转换
    在这里插入图片描述
    强制类型转换不会改变value本身，而是会创建一个新的指定类型的值。
  2. 关于Cpp中的auto
    auto用于根据变量的输入值自动判断变量类型。
auto para = 100.1;	//para belongs to float type
  1. 关于输入函数的使用very key
cin;
cin.get();
cin.getline();
//以及以上的拼接，应对空格与换行符
//应对不同的赋参情况，系统将根据具体参数情况调用对应的重载函数版本

cin.eof() == 1;	//EOF被激活，否则返回0
cin.fail() == 1;	//EOF被激活，否则返回0
//事前检测
//使用EOF将会更智能地检测输入结束。对win下为CTRL+Z加ENTER，其他系统有所不同
cin.clear();
//使用cin.clear()清除EOF的**标记**从而恢复IO

在这里插入图片描述

  1. 使用string类的安全便捷，包括赋值拼接和添加操作。
  2. 比较数组，vector对象和array对象
vector<type_name> para_name(length);
arrar<type_name, length> para_name;

使用.at()限制array或vector检索区域，提高安全性。

  1. 对for循环，新增了基于范围的循环，对于数组或容器的所有元素执行相同的操作。
ary_type ary_name[num] = {...};
for (para_type para_name : ary_name)
	execute_content;
  1. 对于C++中文件读写，使用fstream头文件。并且像在控制台中使用cout一样将流写入文件中或读取文件。使用.open()函数。
  2. 关于引用变量
    在这里插入图片描述
    在这里插入图片描述
    必须在声明引用变量前将变量初始化（不同于指针）。引用在传参和指针传参的作用有点类似，并且更接近于const指针。
    引用多用于传递函数参数，这是对C中只能传递指针的一种超越。
int main()
{
	...;
	para_type & para_name;
	fun_name(para_name);
	...;
}
fun_type fun_name(para_type &para_name)
{
	...;
}
//如果不希望对para进行修改，则一你改改将para变为const变量，若出现修改则报错。key:const与引用变量结合应用
//在main中调用fun_name()时参数应直接用变量而不能用表达式。
//应注意函数不得返回指向临时变量的引用
//需要引用返回值，需要将函数类型变为const引用类型（非const返回值储存于临时单元，使用后会被释放）

在这里插入图片描述

  1. 函数模板（此外还有类模板，后面再谈）
    函数模板用于在应对不同类型参数实现相同功能的情况下，通过编译器自动调整函数体内类型从而简化程序的一种手段。
    Key：代码中模板本身不会生成函数定义，而是指导生成一个函数定义的方案。
template <typename TN>
//typename可替换成class（推荐使用前者），TN=TypeName，用户自定义
func_type func_name(TN para_0, ...)
{
	...
	TN para_1;	//新建一个临时参数
	para_0;		//使用传入的para_0
}
//传入参数时编译器会自动检查参数类型并作自动替换
  1. 重载模板
    在同一个模板名下定义算法不同的模板，编译器会根据调用时不同的参数输入自动匹配不同的算法。
template <typename TN>
func_type func_name(para_lib_1)
{alg_1;}

template <typename TN>
func_type func_name(para_lib_2)
{alg_2;}

//编译器根据调用时参数形式是para_lib_1还是para_lib_2，进而调用不同版本的算法
//这种手法对于含数组，结构体之类的参数很有用
  1. 具体化和实例化
    隐式实例化
    直接从函数模板生成的实例，统称为（隐式）实例化。
    显式具体化
    对于某些特殊类型，可能不适合模板实现，需要重新定义实现，显式具体化基于函数模板的，函数模板的基础上，添加一个专门针对特定类型的、实现方式不同的具体化函数。
template <> func_type func_name<para_type>(para_lib)
{...;}
//显式具体化，当遇到para_type类型参数时，编译器优先调用该型，而不是经过默认模板

显式实例化
当显式实例化模板时，在使用模板之前，编译器根据显式实例化指定的类型生成模板实例。显式实例化只需声明，不需要重新定义。

template func_type func_name<para_type>(para_lib)
{...;}
//显式实例，当遇到para_type类型参数时，编译器根据原模板的定义及该声明直接生成一个实例函数，该函数仅接受para_type型

在这里插入图片描述

  1. 函数版本的选择
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  2. decltype的使用

decltype(x) y;	//使y的类型与x相同，二者可以为表达式
//整个遍历的过程将会十分复杂，因为x，y名可以为常规变量，函数或者结构等。

在更新之后，使用auto声明可以为函数服务。

auto func_name(para_lib)	//decltype在此处无能为力，看不到返回值的类型
{
	...;
	return para_1 + para_2;	//返回结果类型未知
}
  1. 处理预防重复声明的情况
#ifndef content	
...
#endif
  1. 外部链接性（代码块外，或在但文件中使用extern），内部链接性（代码块外，static限定），无链接性（代码块内）
    在这里插入图片描述
    此外还有thread_local，mutable，volatile等一类
    Key：const对外部链接性的影响。
    此外，函数也有extern（可选）和static之分。
  2. 作用域运算符“::”
  3. 动态储存
type_name *start_poi_name = new type_name (para);
//para为初始值
type_name *start_poi_name = new type_name {ary_lib};
//对数组，结构体亦类似
type_name *start_poi_name = new (location_name) obj_name;
//在location_name中建立空间分配给obj_name
//失败时，返回空指针
delete(poi_name);
//释放空间

二、面向对象编程（OOP）

面向对象编程，是一种编程风格。将数据与处理过程剥离，使数据私有不可见，通过类的公共接口与处理过程关联，实现对数据的调用。数据不能直接访问，只能通过接口函数调用。

类：将数据表示和操纵数据的方法封装成一个整体包。（类可以看作一种数据类型）
_一般将类的首字母大写。
_类声明（包括数据和接口）放置在一个.h头文件，方法的定义放置在一个.cpp文件中。
对象：相当于变量，包含所属类的数据和方法。
成员：包括类中声明的各个数据和各个接口函数。

1.类和对象的声明，方法的定义
//Declare a class
//This is a .h file
//head files & parameters declare

#ifndef .h_file
#define .h_file
class class_name
{
private:
//This line could be neglected
	para_lib;
public:
	method_lib;
};
#endif

//Declare methods
//a .cpp file
//head files & parameters declare
#include .h_file

func_type class_name::method_name(para_lib)
//Using :: operator
{operations;}
......
//method members could be varited

//Use class to declare an object
//a .cpp file
//head files & parameters declare

class_name obj_name;
int main()
{
	...
	obj_name.method_name(para_lib);
	...
	//also could do in this way, no need for a object name but use a point to conduct
	class_name * poi_name = new class_name(initialize_lib);
	...
}
2.对象的初始化

由于数据私有，不能直接对对象的数据进行初始化。只能通过类构造函数进行初始化（一般该函数与类名相同），对象使用完成后，通过构析函数完成内存清理工作（一般该过程由编译器自动完成，对于堆栈和静态储存的性质过程会有所不同）（构析函数名为类名前加~）。

//Declare and define an initializing function
//placed in public zone

class_name::class_name(initialize_lib)
//No need for type name, and it return nothing
//initialize_lib should not include private members' name
{
	initialize operations;
	...
}

//In a .cpp file, when need to initialize an object
{
	...
	class_name obj_name(initialize_lib);
	//"class_name obj_name = class_name(initialize_lib)" in short
	//or use point and "new" operation
	...
}

编译器会自动提供默认构造函数：

class_name::class_name() {}
//do noting

一旦给出自定义构造函数，程序员就必须自行提供默认构造函数（可用函数重载实现多种对象初始化函数）。其中，隐式调用默认构造函数不需要加括号（否则为返回该类的函数）。
构析函数：

class_name::~class_name() {}

对于const数据成员和引用数据成员，其需要在执行构造函数之前（即创立对象之前）就对其进行初始化，通过成员初始化列表执行初始化工作（实际上，不仅针对常量成员，所有数据成员据可以用上述方式初始化，多个时在后面补上，用逗号","隔开），注意，这种语法仅能用于构造函数。如下例子：

//.h file
class class_name
{
private:
	const para_type para;
	...
public:
	class_name(para_lib){...};
	...
}

//.cpp file
...
para_type ini_para;
class_name::class_name(para_lib) : para(ini_para)	//initialize constant para
{...}
...
3.const成员函数

当声明对象为const类型时，调用接口时并不能保证是否会对对象做出修改（无论是否真的会改），此时编译器一定会报错。为解决这个问题，对接口做出修改：

//.h flie
...
public:
	func_type func_name const(para_lib);
...

//.cpp file
func_type class_name::func_name const(para_lib) {...}

//.cpp file
...
const class_name obj_name(initialize_lib);
obj_name.func_name(para_lib);
4.this指针和对象数组

在调用两个对象时，我们一般有两种方法。一种是通过提供返回对象成员的函数接口，在类的域外进行数据处理（一般最好加const限定成员不会被修改）。比如：

//.h file
class class_name
{
private:
	para_type para;
public:
	fun_type fun_name(para_lib) const;
	//in case of being rewrited
}

//.cpp file
#include ".h"
class_name::fun_name(para_lib) const
{
	using namespace std;
	return para;
}

//.cpp file
#include ".h"
using namespace std;
int  main()
{
	...
	class_name obj_1, obj_2;
	para_type para_1, para_2;
	para_1 = obj_1.fun_name(para_lib);
	para_2 = obj_2.fun_name(para_lib);
	...
	return 0;
}

现在介绍一种使用this指针的更加简洁的方法，将一个对象传入另一个对象的成员接口函数中，直接在类的作用域中完成操作。

//.h file
class class_name
{
private:
	para_type para;
public:
	const fun_type & fun_name(const class_name & obj) const;
	//return a const type object. transfer a const type object into another object. in case of rewriting any data as well
}

//.cpp file
#include ".h"
class_name::fun_name(const class_name & obj) const
{
	using namespace std;
	...
	return obj;
	//the transfered one
	...
	return *this
	//current object itself
	//"this" is just a pointer while "*this" is the content that we need (the whole object)
	//further more, when need the member of the result, use "->" operator like "this->para"
}

以上用两个对象的案例阐述了this指针的作用，对于有两个以上对象时，使用对象数组：

//.cpp file
int main()
{
	...
	class_name obj_ary_name[para] = 
	{
		...initializing_lib...
		//use "," to separate
	}
}

初始化时每个元素的初始化与单个对象初始化规则相同，没有自定义就默认，可能要重载。
对于数组，通常通过循环指令两两之间逐个进行操作。

5.类的作用域

类中定义的数据与函数作用域为整个类，在类外不可知。针对类、对象和指针，依次分别采用“::”、“.”、“->”三种运算符进一步定位。
声明类时，不能直接用const限定，因为类的声明不占用空间，只用创建对象时才建立存储空间。如：

private:
	...
	const para_type para_name = para;
	//forbidden
	...

解决方法，一是使用枚举变量，二是改用声明static变量将其存储在静态存储区而不是对象中。

//use emun variate (single)
private:
	...
	enum {para_name = para};
	para_type para_name;
	...

//use emun variate (multiple)
private:
	...
	enum class para_name_1 = {para_lib_1};
	enum class para_name_2 = {para_lib_2};
	para_type para_name_1;
	para_type para_name_2;
	...
//.cpp file
	...
	para_name_1::para_mem_1;
	para_name_2::para_mem_2;
	//multiple enum variate could be palced in the same class

//use static variate
private:
	...
	static const para_type para_name = para;
	para_type para_name;
	...
6.运算符重载

在函数重载中，应对不同的数据类型，我们能用同名的函数完成逻辑相同但形式不同的操作。运算符重载的道理亦相同，实际上运算符本身对标准类型就会有重载，对于类运算，我们需要使用operator运算自定义重载形式。

//.h file
class class_name
{
public:
	func_type operator+(para_lib);
	//重载+运算符，声明
	...
}

//.cpp file
func_type operator+(para_lib)
{...}
//定义新运算符样式

//.cpp file
class_name obj1, obj2, obj3;
obj1 = obj2 + obj3;
obj1 = obj2 operator+(obj3);
//以上两种等价，注意需要区分obj2和obj3的次序

运算符重载限制：不能为标准类型重载运算符，不能违反原本运算逻辑，不能修改优先级，不能创建新的运算符，部分运算符不能被重载。

7.友元

友元包括友元函数，友元类，友元成员函数。
友元在类中带friend声明，与成员权限相同，但不是成员，且不带friend和不用限定符定义。
友元应用的一个例子，就是和运算符重载结合在一起，解决交换律的次序问题。

//.h file
class c_n
{
	...
public:
	...
	func_type func_name1(para_lib);
	friend func_type func_name2(para_lib);
	//声明成元函数与友元函数
	...
}

//.cpp file
...
func_type c_n::func_name1(para_lib)
{...}
func_type func_name2(para_lib)
{...}

注意：成员函数和友元函数的传参情况有所不同

8.类与基本类型的转换

类与基本类型的转换，有从基本类型到类，和从类到基本类型两种。
从基本类型到类，需要有类声明中有接受唯一参数的构造函数作为转换函数（要求不应有二义性，即对一种类型仅适配一个单参构造函数），编译器将自动将数据匹配到私有成员中。
注意，从基本类型到类的转换包括隐性转换和显性转换两种。应尽量避免使用隐性转换。

//.h file
class c_n
{
...
public:
	...
	c_n(para_type para);
	//隐性/显性转换声明
	explicit c_n(para_type para);
	//此时仅支持显性转换
}

//.cpp file
...
para_type para;
c_n obj;
obj = para;
//隐性转换
obj = c_n(para);
//显性转换

从类转换到普通类型，需要提供没有类型和没有参数的转换函数（成员函数），该函数返回目标类型

//.h file
class c_n
{
private:
	...
	para_type para;
	...
public:
	...
	fuc_name();
	...
}

//.cpp file
...
c_n::func_name()
{return para;}

//.cpp file
...
para_type para_1;
c_n obj;
para_1 = obj; 
...
9.使用类过程中的内存管理

在使用类的过程中，应该理清在赋值，传参和返回三个过程中，类在内存中的具体存储情况。
主要注意以下几个方面：

  • 针对的过程：类之间的赋值，传递类参数，返回类。（其实上述三种本质上相同）
  • 调用类的方式：传值，传递指针，传递引用，以及以上三者是否组合const
  • 调用是否会触发类的一些自动执行步骤：构造函数，析构函数，以及static成员

值得注意的是，在传值过程中一般会误触发自动执行步骤导致static成员被更改；而传指针会造成重复释放内存，造成程序数据出错（需要进行深度复制）。要思考new和delete在每个步骤的触发情况，以及形式的对应情况。
Key：静态成员函数不能通过对象来调用（无关联性），且只能采用静态成员数据。
Key：指针多数与new和delete连用。
Key：函数返回可以返回（const）对象，返回（const）对象的引用，是否引用的区别在于是否会触发类的自动进程（构造和析构），返回类型应与声明是否含const匹配。引用的效率会更高。

10. 类的继承（is-a关系下的公有继承）

继承可以实现类的扩展和修改，包括再已有类上添加功能、成员和修改类方法，并且不需要访问源代码。
继承是一个类派生出另一个类，原始类为基类，继承类为派生类。以下是一个公有派生：

class c_1
{...};
//base class
class c_2 : public c_1
{...};
//derive class

派生类声明一般与基类声明放在同一个.h文件中。
在权限上，派生类继承了基类的成员和接口，对于基类的私有成员，派生类只能通过基类的接口访问。在扩展上，派生类可以添加自己的数据成员、成员函数和构造函数（服务于新成员）。但是，在基类中添加protected类可使派生类直接访问当中的数据成员。

class c_base
{
private:
	...
protected:
	...	//could be accessed derectly by ex class
private:
	...
}

派生类的初始化，需要通过在给派生类分配内存空间前先通过基类构造函数初始化基类对象，再初始化派生类对象（进入派生类的构造函数中）。而释放对象顺序与上述相反。

//.h file
class cder : public cbase
{...}

//.cpp file
cder::cder(para_lib_1) : cbase(para_lib_2)
{...};

派生类和基类的关系（这个很有趣）

  • 派生类对象可以使用基类的非私有的方法（这个已经知道了）
  • 基类指针或引用可以再不进行希纳是类型转换的情况下指向派生类对象，但是，这种指针或引用只能调用基类的方法（不能调用派生类方法）。（如以下例子）
//.h file
class cbase
{
...
public: 
	func_type men1();
	...
};
class cder : public cbase
{
...
public: 
	func_type men2();
	...
};

//.cpp file
cder obj;
cbase * p = obj;
cbase & r = obj;

p->men1();
r.men1();

p->men2();	//invalid
r.men2();	//invalid
  • 可以将派生类对象赋给基类对象，包括赋值、传参、引用等方式。因为派生类含的信息包含了基类，相当于向下兼容。例如：
//包含了上面代码块的.h file
//.cpp file

#include <".h file">
cder obj;
cbase obj_2 = obj;

虚函数实现公有多态继承。即对于同一个方法，会根据所受调用的对象不同而执行不同的行为。通过关键字virtual实现。

  • virtual声明的函数，程序将根据对象的类型，或者是引用或指针指向的对象调用相应的方法。如果没有virtual声明，程序将根据引用或指针的类型选择方法。（见例子）
  • 注意区别多态继承和函数重载。对于重载函数，必须在基类和派生类的对象中对所有的重载版本都声明virtual。如果只有部分声明，则剩余的在派生类中剩下没有声明virtual的重载版本将会被屏蔽，只能通过基类来调用（如果剩下的没有被修改那倒无妨）。
  • 虚函数主要保证函数同名即可，允许返回类型变化（返回类型协变）。
  • 在虚函数的定义中如果使用到虚函数，必须标明作用域（否则可能会引起混乱或陷入死循环（常见））
  • 若定义了虚函数，则通常要搭配使用虚析构函数（不同方法的内存释放方式不同）。而构造函数不能是虚函数（这样做没有意义，想想就清楚）。
  • 只有成员函数才能声明virtual，友元函数不是成员函数故不能被声明。
//.h file
class cbase
{
...
public: 
	func_type men0()
	{operation_1};
	virtual func_type men(paralib1)
	{
		operation_2;
		...
		cder::men(paralib1);
		//use "::" operator
		...
	}
	virtual func_type men(paralib2)
	{operation_3};
	//func_type could be varied
	...
};
class cder : public cbase
{
...
public: 
	func_type men0()
	{operation_4};
	virtual func_type men(paralib1)
	{operation_5};
	virtual func_type men(paralib2)
	{operation_6};
	//func_type could be varied
	...
};

//.cpp file
...
cbase obj1;
cder obj2;
cbase & r1 = obj1;
cbase & r2 = obj2;	//assumpt it is valided

obj1.men(paralib1);	//use operation2
obj2.men(paralib1);	//use operation5

r1.men0(paralib1);	//use operation1
r2.men0(paralib1);	//use operation4

r1.men(paralib1);	//use operation2
r2.men(paralib1);	//use operation5

虚函数的出现使编译器开发出动态联编的功能（联编：将源码中的函数调用连接到指定的函数块代码）。虚函数通过形成隐藏的虚函数表数组，在执行程序时再链接函数块，以效率降低和存储体积变大为代价。
在虚函数再进一步，就是纯虚函数。声明包含纯虚函数的类不能创建对象。

virtual func_type func_name(para_lib) = 0;	//a pure virtual function

由此，则可以引出抽象基类（ABC，其不能创建对象），抽象基类至少包含一个纯虚函数，由抽象基类可以派生出很多有共同特征的派生类，他们之间特征的交集（共同特征）就是抽象基类。进而通过在派生类中重定义纯虚函数为虚函数，完成具体特征的描述。
最后，关于动态内存分配。若派生类使用了new，则必须为派生类定义显式析构函数、复制构造函数和赋值运算符。（再展开一下吧）

三、泛型编程（GP）

Meakin Lieng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用类作用域操作符进行成员函数调用问题
cjc211322的专栏
08-12 1988
使用类作用域操作符进行成员函数调用问题
千锋C++笔记.zip
08-18
《千锋C++笔记》是一份综合性的学习资料，涵盖了C++编程语言的基础到高级概念。这份笔记由知名教育机构“千锋”提供，旨在帮助初学者和有一定基础的程序员深入理解和掌握C++这一强大的系统级编程语言。下面将详细...
C++学习-指针与结构体
qq_30182357的博客
04-10 112
typedef int Mint; 表示Mint 即为int类型 typedef struct Role { int HP; int MP; }* PRole; int main() { Role user; PRole puser = &user; puser->HP = 50; user.HP = 50; puser->MP = 50; user.MP = 50; }
C++基本数据类型转换
Liu_Xiao_Ming的博客
08-16 1220
代码： #include &amp;amp;amp;lt;iostream&amp;amp;amp;gt; #include &amp;amp;amp;lt;string&amp;amp;amp;gt; #include &amp;amp;amp;lt;cstdlib&amp;amp;amp;gt; /* 时间：2018.06.28 类型转换 */ #define CHAR_TO_INT(x) int(x - '0') void Show
【Applied Algebra】c++大整数计算GMP库的安装和使用(Ubuntu/Mint)
MinCong Luo的博客
12-28 2955
c++大整数计算GMP库的安装和使用(Ubuntu/Mint) GMP库(详情见在线文档)一个免费的任意精度的大数算术库,可对有符号整数、有理数和浮点数进行计算操作;除了GMP运行的计算平台中可用内存所指定的限制外,精度没有实际限制.GMP有一套丰富的功能,主要目标应用是密码学应用和研究、互联网安全应用、代数系统、计算代数研究等. 安装 注意加上"–enable-cxx"以使得c++可以调用(这样才会生成"libgmpxx.so"); [hanss@Mint]$ ./configure --enab
Const用法总结
andy_miao858 blog
10-27 391
Const用法总结 1.       把一个const对象的地址赋给一个普通的、非const对象的指针会导致编译时的错误。 const double pi = 3.14; double *ptr = π  // error: ptr is a plain pointer const double *cptr = π // OK: cptr is a pointer to con
二级C++笔记.docx
01-20
"二级C++笔记.docx" 一、选择题 1. 结构化程序设计的基本原则： 在结构化程序设计中，有四个基本原则：自顶向下、逐步求精、模块化、限制使用 goto 语句。这四个原则是软件设计的基础，遵循这些原则可以提高软件...
C++笔记.zip_C++_笔记
07-13
本资料"**C++笔记.zip**"提供了全面的C++学习资料，特别是针对C++初学者和进阶者的一份宝贵的资源集合。 **C++基础** C++的基础部分包括语法、变量、数据类型、运算符、流程控制等。C++支持基本的数据类型如int、...
C++笔记.md
06-25
C++笔记.md
达内C/C++笔记
10-17
C++笔记可能涵盖了C++的更多高级特性，如模板元编程、STL的深度使用、设计模式、多线程编程、Boost库的运用等。这些内容可以帮助开发者写出更加高效、可维护的代码。 1. **模板元编程**：在编译时进行计算，减少...
const用法大全
chenwk891的专栏
02-06 1761
本文为转载 原文出处：http://www.cnblogs.com/wintergrass/archive/2011/04/15/2015020.html C++作为一种面向对象的经典语言，它是非常的强大，它的每个部分都值得我们去深入了解。 const的基本概念：      const名叫常量限定符，用来限定特定变量，以通知编译器该变量是不可修改的。习惯性的使用const，
C++实验6
Mintshine的博客
05-18 316
一 问题及代码 /* * 文件名称：Ex1-1.cpp * 作 者：张俱珲 * 完成日期：2017 年 5月 10日 * 版 本 号：v1.0 * 对任务及求解方法的描述部分: * 输入描述：无 * 问题描述：已知有两个有序的数组A,B，将这两个数组合并到数组C中，数组C依然有序，如a[5]={1,3,8,9,10}，b[5]={2,3,4,5,6}，则c[10]=
#pragma 用法
mmdev
07-10 223
今天刚开始调试windows核心编程中的例程就感觉十分难懂，原因是自己的c++基本功力实在太弱了首先在windows编程的过程中大量的使用宏的问题。＃pragma 的用法在所有的预处理指令中，#Pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。#pragma指令对每个编译器给出了一个方法,在保持与C和C ++语言完全兼容的情况下,给出主机或操作系统专...
浅谈宏定义使用技巧
轻飘飞扬
03-17 5036
1、宏定义介绍          宏定义又称为宏替换，简称宏。它是在预处理阶段用预先定义的字符串替代标识符的过程。其定义的一般形式为：  #define    标识符    字符串        宏定义中的标识符都采用大写，这是编程中一种约定俗成的习惯。在了解如何使用宏定义之前，我们先来了解使用宏的过程中需要注意的几个要点。       1）宏替换不做语法检查，所以在使用的时候要格外小心。
let和const----你所不知道的JavaScript系列（2）
weixin_30765505的博客
06-27 210
let 众所周知，在ES6之前，声明变量的关键字就只有var。var声明变量要么是全局的，要么是函数级的，而无法是块级的。 var a=1; console.log(a); //1 console.log(window.a); //1 function test(){ 　　var b=2; 　　function print(){ 　　　　console.log(a,b...
函数中关于const关键字使用的注意事项
weixin_30768175的博客
10-17 175
我们知道C++中const可以用于修饰普通变量、指针变量、引用变量、函数入参以及函数名，例如： //常量 const int nMaxNum = 5; //修饰引用 const int& refInt = nMaxNum; //修改指针 const int *p ...
const与&引用
u013571243的专栏
06-09 4006
书上的一个例子 #include class Complex { public: Complex():real(0),imag(0){}; Complex(double r, double i):real(r),imag(i){}; Complex(double r):real(r),imag(0){}; // 定义转换构造函数
C语言：刷题笔记
weixin_45930573的博客
09-04 402
c语言刷题记录
【C++】STL—vector的使用
最新发布
2301_77112794的博客
09-04 693
本文介绍了vector重点函数接口的使用
清华大学C++笔记精华：面向对象编程与程序开发
C++笔记精华是一份详细的学习资料，它涵盖了清华大学出版的《C++程序设计》课程内容，适用于那些希望通过学习这门课程深入了解C++编程的同学。C++的历史可以追溯到1980年代，贝尔实验室对C语言进行了改进，引入了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值