C++简易基础--快速上手

最新推荐文章于 2024-08-29 14:44:20 发布

中古传奇

最新推荐文章于 2024-08-29 14:44:20 发布

阅读量1.5k

点赞数 3

分类专栏： C++ 编程语言文章标签： c++ 面试 java

本文链接：https://blog.csdn.net/li_kin/article/details/121635563

版权

编程语言同时被 2 个专栏收录

31 篇文章 1 订阅

订阅专栏

C++

4 篇文章 0 订阅

订阅专栏

1 命名空间

命名空间包含了逻辑结构上相互关联的一组类、函数、模板等。命名空间像是一个容器，把某些在逻辑结构上相关的 “ 对象 ” 放在一起并与外界区分。特别的，命名空间里的变量名或类名可以和命名空间外的变量名或类名重名。

1.1 如何使用命名空间

用花括号把声明块括起来，再以关键字namespace开头并命名，其基本格式如下：

namesapce name{
	声明块
}

其中声明块中可以包含变量、类、函数等。例如：

namespace S{
	int x;
	void FunA(){
		...
	}
}

在命名空间外使用命名空间内的成员：命名空间的名字加上作用域运算符 :: 。
参考上例namespace S,若访问x，即写成S：：x;访问 FunA()，则为S::FunA()。
命名空间的嵌套，具有分层屏蔽的作用。例如：

namespace S1{
	namespace S2{
		int x;
		void FunA(){
			...
		}
	}
}

若要访问x,则可访问S1::S2::x,同理FunA()则可写为S1::S2::FunA().

1.2 using 使用

using namespace后不能类名或者变量名。using 指示符的使用：以关键字 using namespace 开头后跟命名空间名字。
一次性地使命名空间内的全体成员被直接使用。

1.2 C++语言的输入与输出–标准I/O库

C++ 标准 I/O 库包含 iostream、fstream 和 sstringstream。 iostream、fstream 比较常用， sstringstream一般用作于数据的格式化。

常用I/O库

2 数据类型

变量：全局变量和局部变量
由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用，全局变量是可以被本程序所有对象或函数引用。
重名现象：当全局变量与局部变量重名的时候，起作用的是局部变量，全局变量被屏蔽掉。

2.1 基本数据类型

数值类型：
string类型：
struct类型：struct 是由一系列相同或不同的数据类型组成的数据集合，也称结构体，是一种复合型的数据类型。

struct struct_name
{
    memberList
}varList
//  struct 为结构体的关键字，struct_name 为结构体的名字;
//  memberList 为结构体成员变量及成员函数的列表;
//  varList 为结构体声明的变量;使用 varList.元素名 可调用结构体中的元素。

2.2 运算符与表达式

sizeof()：用于计算对象类型或表达式结果类型在内存中所占的字节数，其形式为：sizeof (对象类型名) 或 sizeof(表达式)。
逗号运算符：表达式1,表达式2，定义了从左到右的求解顺序，例如 a = 1,a + 1 其值为 2。

3 程序运行的内存分配方式

C++ 程序在运行时，计算机内存被分为程序代码区、全局数据区、堆区、栈区四个部分。
一是介绍 C++ 三种内存分配方式，二是使用 new 关键字和 delete 关键字管理堆内存。

3.1 内存分配三种方式

不同的内存分配方式，有不同的内存调度机制。C++语言的三种内存分配方式分别是：静态存储区分配，栈内存分配和堆内存分配

静态存储区分配
静态分配方式下的内存在程序编译的时候就已经分配好了且存在于程序的整个运行过程。

例如 static 变量，其生命周期随程序的结束而结束，而非像一般变量随函数或作用域的结束而结束。
除了 static 变量，还有一种全局对象 static object，也可以存放在静态存储区。

栈内存分配
栈内存分配方式下的内存是存在于某作用域的一块空间。
例如调用某个函数时，函数内局部变量的存储单元可以在栈上创建，函数执行结束时，这些内存单元会被自动释放。
函数内局部变量的生命周期：起于变量声明，止于函数执行结束。
堆内存分配
堆内存分配：也称动态内存分配，通常使用 new 和 delete 关键字进行管理。堆内存空间可由用户手动分配和释放，所以其生存周期由用户指定，较为灵活。但频繁的分配、释放大小不同的堆空间会产生内存碎片。

3.2 管理堆内存

C 语言中一般使用 malloc() 函数来分配内存空间，free() 函数来释放内存空间。
但在 c++ 语言中我们使用 new 关键字来分配内存空间，delete 关键字来释放内存空间。
指针是一个变量，其值是另一个变量的地址

type* pointerVar-name

3.2.1 new关键字

new关键字用于堆内存的分配，可自动计算所要分配内存空间的大小，基本使用形式为：

// 指针变量名 = new 类型
int* p; //定义一个整型指针变量
p = new int;	//表示动态分配一个存放整型数据的内存空间，并将其首地址赋给整型指针变量 p
// delete 关键字用于堆内存的释放
delete p;	// 表示释放指针变量 p 指向的内存空间,此时省略指针变量 p 前的 *。

4 基本控制结构

常用嵌套：

// for嵌套
for(循环变量初始化1; 循环条件1; 循环增量1)
{
    for(循环变量初始化2; 循环条件2; 循环增量2){
        代码块2
    }
    代码块1
}

// while嵌套
while(条件1){
    while(条件2){
        代码块2
    }
    代码块1
}

// do-while循环
do{
    代码块1
      do{
        代码块2
    }while(条件2);
}while(条件1);
// 尽量避免设计层次过多的循环嵌套。

// for嵌套里面if条件
for(循环变量初始化;循环条件;循环增量)
{
    ...
    if(判定条件){
    判定条件为 TRUE 时的执行语句
    }
    else{
    判定条件为 FALSE 时的执行语句
    }
}

//

4 函数

一个 C++ 程序由一个主函数和若干子函数组成。主要有三部分：函数定义与调用；参数传递及拓展知识；
C++ 中的函数分为 C++ 标准库函数和自定义函数。使用标准库函数需要包含特定的头文件，比如使用 vector 功能时，需包含头文件 #include。
而自定义函数是用户自定义命名和声明的一组语句，其基本结构为：

// Datatype 为函数的返回值类型；name 为函数的名称，也是调用函数所使用的标识符；parameter list 为传递给函数的参数列表；code 为函数的主体，存放函数需要执行的语句
Datatype name(parameter list){
	code
}
// 函数申明：希望在定义函数前调用函数，则需要在调用函数前声明函数，其结构为：
type name(parameter list);

// 例如
int add(int a,int b); //函数声明。

int main(){
    调用 add 函数 //在未定义函数前调用函数。
}

int add(int a,int b){
    return a + b;
} //定义函数

4.1 函数的申明与调用

// 函数调用：调用函数时，需暂停主调函数的执行，转入执行被调函数，当被调函数执行至 return 语句或函数末尾时，
// 被调函数执行完毕，转回执行主调函数
// 实参列表应与函数原型的参数个数及参数类型一致：

#include <iostream>
using namespace std;

int add(int a,int b); //函数声明。

int main()
{
    int x,y;
    cout<<"input x y:"; //输出提示信息。
    cin>>x>>y; //通过输入的方式给 x y 赋值。
    int c=add(x,y);//在未定义函数前调用函数。将函数的返回结果赋给变量 c。
    cout<<c<<endl;//输出 c 值。
    return 0;
}

int add(int a,int b)
{
    return a + b;
}

4.2 参数传递

函数的参数传递指的是形参与实参结合的过程，其基本方式包括值传递和引用传递两种。
形参的本质和局部变量相似，在进入函数的时候创建，退出的时候销毁

值传递
该方法把参数的实际值复制传递给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。

void swap(int a,int b){ //定义空函数 swap，用于交换 a 和 b 的值。
    int t=a; //定义中间变量 t，并将 a 的值赋给变量 t。
    a=b; //将 b 的值赋给 a。
    b=t; //将 t 的值赋给 b，又因为 t=a，所以把 a 的值赋给 b。
}

引用传递
使用引用传递，需要在定义函数时，在参数前加上符号 &，该方法把参数的引用复制给形式参数，修改形式参数会影响实际参数。

void swap(int &a,int &b){ //定义空函数 swap，用于交换 a 和 b 的值。
    int t=a; //定义中间变量 t，并将 a 的值赋给变量 t。
    a=b; //将 b 的值赋给 a。
    b=t; //将 t 的值赋给 b，又因为 t=a，所以把 a 的值赋给 b。
}

3.指针传递

void swap(int *a,int *b){ //定义空函数 swap，用于交换 a 和 b 的值。
    int t=*a; //定义中间变量 t，并将 a 的值赋给变量 t。
    *a=*b; //将 b 的值赋给 a。
    *b=t; //将 t 的值赋给 b，又因为 t=a，所以把 a 的值赋给 b。
}

默认参数：当调用函数时，如果用户指定了参数值，则使用用户指定的值；如果参数值缺省，则使用默认参数。
函数重载：指定义一个参数类型或参数个数不同的重名函数。当程序执行时，编译器将调用参数类型与函数形参类型一致的函数

5 类和对象

面向对象程序设计的基本特点、类的定义和类成员的访问控制、对象的声明。
抽象、封装、继承、多态；类的定义；类成员访问控制；对象的声明；类的成员函数

抽象：抽象是指对具体问题或对象进行概括，抽出其公共性质并加以描述的过程。一般情况抽象分为数据抽象和行为抽象，其中数据抽象是指一个对象区别于另一个对象的特征，行为抽象是指某类对象的共同行为。
封装：封装是指将抽象得到的数据和行为相结合，隐藏对象属性和实现细节且仅对外提供公共访问方式的过程。
继承：继承是指通过代码复用在保持原有类特性的基础上对子类进行具体说明的过程，通俗来说继承就是精简重复代码的手段。
多态：多态是指一段程序能够处理多种类型对象的能力，函数重载就是实现多态的一种手段。在 C++ 语言中多态可分为强制多态、重载多态、类型参数化多态和包含多态。

5.1 类

类是 C++ 语言支持面向对象思想的重要机制，是实现封装的基本单元。
类的定义：类一般由类名、数据成员、函数成员三部分组成。

// 定义类
class 类的名称{
	public：
        外部接口
    protected：
        保护性成员
    private：
        私有成员
}
// 其中 public、protected、private 表示访问控制属性，用于控制类成员的访问权限。特别的，没有分配控制属性的默认为 //  // private 私有成员。

//成员访问控制

// 使用 public 关键字声明的公有成员可在类外访问，即公有类型成员定义了外部接口。


// 使用 protected 关键字声明的受保护成员可在子类中访问。

// 使用 private 关键字声明的私有成员只能被本类的成员函数访问。

5.2 对象

在C++语言中，对象是某类事物的例。

// 其形式为类名 对象名；
area square;

// 访问对象的成员：
对象名.成员名
// 访问 函数成员的基本形式为：
对象名.函数名(参数表)
squeare.setwitdth(3.2)

5.3 类的成员函数

成员函数描述了类的行为。成员函数在类中只用说明其函数的返回类型、名字和参数表，而函数的具体实现基本在类外说明。
其基本形式为：

class 类名
{
    函数的返回类型 函数名(参数列表)
}

返回值类型 类名::函数名(参数列表) //在类外说明函数的具体实现时，需要使用类名限制成员函数，其形式为：类名::函数名(参数列表)。
{
    函数体
}

class area
{
    ...
    void setwidth(double wid);
    ...
}

//在类外说明函数的具体实现
void area::setwidth(double wid)
{
    函数体
}

6 数组字符串和指针

共有五个内容：数组多维数组字符串指针变量的神明和使用区别指针和引用。
数组的声明格式为：

type name[elements] //一维数组的声明格式。
// type为数组类型，name为数组名，elements表示数组长度。
int a[5]; //包含五个元素的 int 数组。
float a[5]; //包含五个元素的 float 数组。
char a[5]; //包含五个元素的 char 数组。
// 访问数组：下标索引；

//字符串常用函数，引用C的cstring头文件
函数	作用
strcpy(s1,s2)	复制字符串 s2 到 s1
strcat(s1,s2)	将字符串 s2 连接到 s1 末尾
strlen(s)	计算字符串 s 长度
strcmp(s1,s2)	比较字符串 s1 和 s2 的长度，相同为 0；s1 < s2 为 -1；s1 > s2 为 1
strchr(s1,ch)	返回一个指针，指向 s1 中字符 ch 第一次出现的位置
strstr(s1,s2)	返回一个指针，指向 s1 中字符串 s2 第一次出现的位置

//C++上ｓｔｒｉｎｇ类

２．指针和引用
指针变量用于存放内存地址。在使用指针之前，需对指针进行声明，其一般形式为：

type *pointer_name;
//　指针实际存放的是内存地址，不同类型的指针变量用于指向数据类型不同的变量或常量。

＊和＆：分别表示指针运算符和取地址运算符。

引用是指对已存在的变量别名，我们可以使用引用名来指向对象。
＊＊引用与指针主要有三个区别：＊＊
＊　可以通过指针名=0 描述一个空指针，但不存在空引用。
＊　初始化时间：指针可在任何时间进行初始化操作，而引用只能在定义时进行初始化操作。
＊　指针变量指向内存的一个存储单元；而引用只不过是原变量的一个别名而已。

Dａｔａtype &引用名=被指对象名；