#include <iostream>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
#include<string>
using namespace std;//表示命名空间std，命名空间的作用是为了消除同名引起的歧义
int main() {
	int oneInt1,oneInt2;
	char strArray[20];//用字符数组oneArry来表示字符串 
	string str;//用String类的对象来表示字符串 
	double oneDouble;
	char oneChar='a';
	cout<<"输入两个整型值，一个字符，一个字符串和一个浮点值,";//字符串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。 
//cout输出
	cout<<"以空格、Tab键或者 <Enter>键分隔："<<endl;
	cin>>oneInt1>>oneInt2>>oneChar>>strArray>>oneDouble;//cin输入
	str = strArray;
	cout<<"输入的数据是："<<endl;//endl的作用是换行 
	cout<<"字符串是：\t\t"<<str<<endl//\t是制表符Tab 
		<<"两个整型值分别是：\t"<<oneInt1<<"和\t"<<oneInt2<<endl
		<<"字符是：\t\t"<<oneChar<<"\n"//"\n"的作用和endl的作用一样，表示换行 
		<<"浮点值是：\t\t"<<oneDouble<<endl; 
	 
	return 0;
}

3：运行结果

4：注意事项

假如cin和cout包含的项过长时，可以将其写在多行中，可以在>>和<<分行，但>>和<<后买你只能跟一个项，不能多个项连用：

cout<<a,b,c; //这种写法只能输出a的值

cout<<a<<b<<c;//正确写法

cout<<a+b+c;//由于<<后是一个表达式，所以可以看作是一个项目，正确。

三：头文件和命名空间

头文件，我们可以理解成在打仗时需要调用的各种武器。C语言中使用头文件保存程序中用到的声明，C++也是如此，当程序中使用cin和cout时必须在程序的最前面包含输入和输出的标准流iostram，每条#include指令仅包含一条头文件，如果需要多个文件头，就需要多条#string指令。

常用的头文件有以下一些

标准输入输出流	<iostresm>
标准文件流	<fstream>
标准字符串处理函数	<string>
标准数学函数	<cmath>

除了使用系统提供的头文件外，还可以定义自己的文件头，并在程序中使用#include指令将其包含起来。使用尖括号括住系统提供的文件头，使用双引号括住自己定义的头文件。

使用关键字namespace把大量的有逻辑联系的程序实体组合在一个标识符下，C++标准程序库中的所有标识符都定义在一个名为std的命名空间中，当程序使用标准标准程序库中的标识符时，如果没有语句“using namespace std；”则cin和cout都没有定义，string和endl也是如此

定义一个命名空间(名字空间）的语法格式：

namespace 命名空间名

{

命名空间内的各种声明（函数声明、类声明、...)

}

引用其他命名空间的标识符的语法

命名空间名：：标识符名

C++提供的using语句可以简化以上写法

using 命名空间：：标识符；//可以在本文件中直接使用该标识符

using namespace 命名空间名；//可以在本文件中直接是使用指定命名空间的所有标识符

四：强制类型转换运算符

当不同的类型的变量进行混合运算的时候，系统会进行合理的类型转换，我们也可以使用强制类型转化运算符 static_cast（用于将一种数据类型转换成另一种数据类型）或者 const_cast （用于去除指针和引用的常量性，但是不能去掉变量的常量性）进行转换。

static_cast <类型名> （表达式）

const_cast <类型名> (表达式）

1：代码示例

#include <iostream>
using namespace std; 
int main() {
	int a=10;
	const int*p =&a;//不能使用常量指针p来修改a的值
	const int ca = 30;//被const修饰
	int *q;
	cout<<"a的地址是：\t"<<&a<<"\ta的值是：\t"<<a<<endl;
	cout<<"*p指向的地址是："<<p<<"\t*p的值是:\t"<<*p<<endl;
	q =const_cast<int*>(p);//去除p的常量性，赋值给q int型
	*q=20;
	cout<<"a的地址是:\t"<<&a<<"\ta的值是：\t"<<a<<endl;
	cout<<"*p指向的地址是："<<p<<"\t*p的值是：\t" <<*p<<endl;
	cout<<"*q指向的地址是："<<q<<"\t*q的值是：\t" <<*p<<endl;
	cout<<"分界线"<<endl;
	p=&ca;//ca的值不能被修改
	q=const_cast<int*>(p);
	*q=40;
	cout<<"ca的地址是：\t"<<&ca<<"\tca的值是：\t"<<ca<<endl;
	cout<<"*p指向的地址是："<<p<<"\t*p的值是：\t"<<*p<<endl;
	cout<<"*q指向的地址是："<<q<<"\t*q的值是：\t"<<*q<<endl; 
	return 0;
}

在这一个程序中，我们定义了一个常量型的p，和一个非常量的指针q。如果直接将p的值直接赋值给q，编译出来会出现错误，但是当我们使用强制性类型转换的话就会成功。

2：程序解释

又发现分界线前后的p和q的地址相同，但是出现了值不相同的情况：当我们用同样的方法处理ca的时候，ca有了const属性，因此ca的值不会发生改变。即使我们将ca的指针p的const属性去掉然后重新赋值给q，再对q的值进行修改，并将所指的内容进行更改，还是不会对ca的值进行修改。因此就出现了变量ca的地址和指针q指向的地址相同但是值不同的情况。

五：函数参数的默认值

在C++语言中，可以在声明函数时为形参指定默认值，当我们在调用有默认参数值的函数时调用语句中可以不给出对应的实参，这就相当于调用该函数的默认值作为参数。指定默认值时不仅可以用常熟，还可以用任意有定义的表达式作为参数的默认值，但不允许是函数的局部变量。注意要先定义再声明最后再调用。

代码示例

#include <iostream>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;
void func(int a=11,int b=12, int c=33) //为参数a，b，c分别设置默认值
{
	cout<<"a="<<a<<",b="<<b<<",c="<<c<<endl;
 } 
int main(int argc, char** argv)
{
	func();//调用时缺少了三个实参，就是用定义的参数的默认值，也就是无返回值 
	func(13);//调用时缺少后面的两个实参，就调用后买你凉饿参数定义的默认值
	func(13,14);//调用时缺少最后一个实参，最后一个就使用被定义中的默认值
	func(13,14,666); //三个参数均可调用实参，就不会使用定义中的默认值 
	return 0;
}

1：注意事项

C++语言中规定：提供默认值时并且在函数声明时，必须按照从右至左的顺序提供，有默认值的形参必须在形参列表的最后。可以理解为，在有默认值的形参右侧，不能有无默认值的形参。

声明函数时，形参的最大默认值是从右至左

调用函数时，实参与形参是从左至右进行匹配对应的

2：简单举例

void defaultvalue1（int = 2，double = 3.0）;//对函数进行声明，正确。

void defaultvalue2 （int a，double = 3.0）;//b有形参，并且在b的右侧没有出现没有默认值的形参，正确。

void defaultvalue3（int a = 2，double b）;//错误，a有形参，但是在a的右侧忽略了b的默认值。


假设给出如下函数声明:
void func(int a,int b=2,int c=3);
则：
func（1，22，33）；//正确
func（）；//错误，a没有声明默认值，必须给出实参值
func（10，20）；//正确，参数c没有给定实参值，因此调用默认值3
func（5，，8）；//错误，从左至右给定实参值不能间断

假设给出如下的函数和变量声明：
int Max（int m,int n);
int a,b;
void func2(int x,int y = Max(a,b),int z = a-b)
{.....
}
则下列函数：
func2（4）；//正确
func2（4，6）；//正确

函数参数的默认值可以写在声明函数的地方，也可以写在定义函数的地方，但是不能两个地方都写。

六：引用和函数参数的传递

1：什么是引用

引用就好比是我们给变量起的一个别名。变量对应于某个内存地址，如果我们给变量起一个别名，就相当于变量和引用均对应到同一个内存地址。

类型名 &引用名 = 同类型的某变量名

int oneInt;//定义一个整型变量

int &name1 = oneInt;//name1就是一个引用，就是oneInt的别名，它的类型是int &型。

当我们声明引用后，系统并不为name1分配空间，name1和oneInt对应的是同一个地址，于是可以相互赋值。

当我们在引用时，变量已经进行初始化。系统会自动将变量初始化为0，不能出现空引用或者是声明引用的引用。引用名必须是一个合法的标识符。在定义引用的时候需要进行初始化。同一个变量的引用可以有多个。

2：常引用和普通引用

int oneInt;

const int &name1=oneInt;//定义了name1，它的类型是const int &。

常引用和普通引用的区别：

常引用：不能修改引用的变量值。

普通引用：可以修改引用的变量值。

代码示例

#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv) 
{
	int oneInt = 1;//定义一个整型变量
	int & ref = oneInt;//普通引用  ref是oneInt的引用，是int & 类型
	const int & refc =oneInt;// 常饮引用 refc是oneInt的普通引用 
	ref=2;//修改ref的值，此时ontInt的值也被修改为2 
	cout<<"ontInt="<<oneInt<<","<<"ref="<<ref<<endl; 
	cout<<"refc="<<refc<<endl;//refc输出的是2，oneInt被普通引用做出了修改
	oneInt=3;//ref被修改为3 
	cout<<"ref="<<ref<<endl;
	cout<<"refc="<<refc<<endl;//ref和refc均输出为3
	int & refd = ref;//refd是ref的的引用，属于引用的引用，refd和ref都是oneInt的引用 
	cout<<"refd="<<refd<<endl;
  /*refc=4;
	cout<<"refc="<<refc<<endl; 
	ref是常引用，不能对引用的变量值进行修改 
  */
	return 0;
}

4：传值和传引用

在程序中不仅可以定义变量的引用，还可以用在函数中。

在C++中，函数调用时参数的传递方式有两种：传值和传引用

传值：本质上就是传递对象的值。

如果函数的形参不是引用，那么在调用时实参传递给形参的就是传值的方式，就是将实参的值拷贝给形参。在函数执行过程中均对该拷贝进行，函数执行完毕返回后，形参的值并不会拷贝会实参，也就是函数内部的形参不会影响到函数外部的形参。（当我们在进行传值时，将实参的值拷贝到栈中对应的形参的地址中，函数内部对形参的操作就是对这个地址的操作，而不是对实参所占用的地址进行操作的）

传引用：传递对象的首地址值。

如果函数的形参是引用，那么就采用传引用的调用方式。在传递的时候，形参对象名就相当于实参对象名的一个别名，两者等价，相当与传同一个地址，可以理解为是传地址。

代码示例

#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
void SwapValue(int a,int b)
{
	int tmp;
	tmp = a;
	a=b;
	b =tmp;
	cout<<"使用SwapValue中 a="<<a<<", b="<<b<<endl; //传值过程中，两个值在函数内部进行互换 
}
void SwapAddress(int& a,int& b)
{
	int tmp;
	tmp = a;
	a=b;
	b = tmp;
	cout<<"使用SwapAddress中 a="<<a<<", b="<<b<<endl; //传引用过程中，对形参进行引用，就相当于对a，b实参进行操作，因此在调用过程中和调用结束，值都会发生交换。 
}
int main(int argc, char** argv) {
	int a=10,b=100;
	cout<<"数据交换前 a="<<a<<",b="<<b<<endl;
	SwapValue(a,b);
	cout<<"调用SwapValue后 a="<<a<<", b="<< b<<endl;//传值结束后，实际上交换的是形参所在的内存地址中的内容，原来实参所在的地址并没有发生改变，因此函数调用结束后，值恢复。
	a=10,b=100;
	SwapAddress(a,b);
	cout<<"调用SwapAddress后 a="<<a<<",b="<<b<<endl; //传引用结束后，a，b两值发生交换成功。 
	return 0;
}

运行结果

引用运用到函数中，既可以当作函数的参数，也可以作为函数的返回值。

数据类型 & 函数名（参数列表）;

代码举例

#include <iostream>
using namespace std;
int oneX = 10;
int oneY =100;
int & refValue(int & x) 
{
	return x;
}
int main()
{
	refValue(oneX)=20;//返回值是引用  
	cout<<"oneX="<<oneX<<endl;//输出20 
	refValue(oneY)= 200;
	cout<<"oneY="<<oneY<<endl;//输出200 
	
}

七：const 与指针共同使用

在C++中，使用const 限定访问权限，可以告诉编译器，所修饰的量是不能改变的，也就是不能作为左值使用。

在程序中使用指针，涉及有两个量：指针本身和指针所指向的内容。

当const 和指针共同使用时，书写位置不同，含义不同。

const修改指针变量时，基本含义：

唯一的const 位于 * 左边，表示指针所指数据时常量，数据不能通过本指针修改；

唯一的const 位于 * 右边，表示指针本身就是常量，不能让该指针指向其他内存地址；

* 左右各有一个const时，表示指针和指针所指的数据都是常量，都是不能被修改的。

代码示例

#include<iostream>
using namespace std;
int main()
{
 int a1=3;//普通变量，a1的值可被修改
 const int a2=a1;//数据是常量，数据不能通过本指针进行修改，a2的值不能被修改
 int * a3=&a1;//普通指针指向普通变量，*a3可以被修改值
 const int *a4=&a1;//数据时常量，a4的值不能被修改
 int * const a5=&a1;//指针时常量，不能修改指针，到那时a5的值可以被修改
 int const * const a6=&a1;//数据是常量，指针也是常量
 const int * const a7=&a1;//数据是常量，指针也是常量
}

const 修饰规则：如果const是本行第一个标识符，则修饰右侧的内容；其余情况下const 修饰其左侧的内容。

八：函数重载

在程序设计中，通过一个函数名形参和返回值不一样，可以减少命名空间。

在面向对象程序设计中，是允许函数重载的。函数重载是指在程序的同一范围内声明几个功能类似的同名函数。使用同一个函数名作为功能一样的函数的函数名，并分别为其编写函数体，可实现各自的功能。

代码示例

//求两者中较大值的函数重载
int bigger(int x,int y)
{
 if(x>y) return x;
 else return y;
}

float bigger(float x,flaot y)
{
 if(x>y) return x;
 else return y;
}

double bigger(float x,flaot y)
{
 if(x>y) return x;
 else return y;
}

//计算一个数值的绝对值的函数，也可以统一命名
int abc(int n)
{
 return (n<0 ? -n:n);
}
float abc(float f)
{
 if(f<0) f=-f;
 return f;
}
double abc(double m)
{
 if(m<0) m=-m;
return m;
}

函数重载必须满足的条件：

参数表中对应的参数类型不同

参数表中参数个数不同

错误的重载方式：

void print(double);

void print(double &);//这两个函数，都可以使用一个对象作为实参，所以编译去区分不了调用的函数版本

float add(int,float);//整数和浮点相加，返回值是浮点

int add(int,float);//编译阶段，程序还没有执行，确定不了类型，因此编译器不能根据返回值确定应该调用那个函数。

注意事项

在两个函数同名但是参数个数不同，但是其中参数多的那个函数参数又可以读取默认值的情况下，可能会引发二义性：

假如我们定义了重载函数Sum（）

int Sum(int a,int b, int c=0);

int Sum(int a,int b);

int Sum(1,2);//调用该函数会出错，因为编译器不知道应该以（1，2，0）作为参数去调用Sum（）函数，还是以（1，2）作为参数去调用Sum（）函数。

九：指针和动态内存分配

1：指针

指针变量中保存的是一个地址，有时也称指针指向一个地址。

我们来看一个例子：

int a=100,*p = &a;

这里，&是取地址符号，p是一个指针，指向整型变量a，那么p中就保存a的地址，p指向地址中的值是100，但不是p=100。这里我们要区分地址和地址中的值，指针变量的值就是地址值，C++中指针变量是个变量，而不是地址。

2：动态分配

在C++程序编译的过程中进行静态内存分配，在程序执行过程中采用动态内存分配。

p = new T;

//T是任意类型名，p是类型为T*的指针。这样的语句会动态分配出一片大小为sizeof（T）的字节的内存空间（Sizeof是C/C++中的关键字,它是一个运算符,其作用是取得一个对象(数据类型或者数据对象)的长度(即占用内存的大小,以byte为单位），并且会将该内存空间的起始地址赋值给指针p；

int *p = new int；//*的作用是取内容，在运行过程中会动态分配一个内存空间，p指向这个空间的首地址，然后通过指针p可以读写该地址的内存空间。

* p =5；//表示向该空间中存入数值5。

动态分配一个整形数组

int *pArray;//指向数组的指针
int i=5;
pArray=new int[i*20];//表示分配了100个元素的整型数组
pArray[0]=20;//表示数组的第一个值，数组的下标都是从零开始的的
pArray[99]=30;//数组的最后一个值

当我们在使用new运算符动态申请空间时，运行完毕后需要释放。C++中提供了一个用来释放动态分配内存空间的运算符 delete

int *q= new int;
*q=8;
cout<<*q<<endl;
delete q;//q指向动态分配的空间

//假如我们使用 new 运算符动态分配一个数组，那么在释放数组时的语句如下
delete []指针;

需要注意的是，当我们使用delete 释放掉指针所指的空间后，如果再访问这个空间，也会得不到想要的结果。

十：用string 对象处理字符串

string是一个类，这个类型的变量是“string对象“，在接下的学习中，我们会更深入的介绍它。我们先可以把它理解为一个数据类型。也就是string类的对象，一个string类的对象可以用来保存一个具体的字符串。

不论字符串的长度如何，再同一种系统下，保存字符串的内存首地址是一样长的，也就是一个 string对象大小是固定的。

在程序中使用 string 对象时，必须在程序的包含头文件 string ，也就是再程序的最前面加上：#include <string>

1：string 对象的声明

string 变量名；

对string对象的初始化

#include <iostream>
#include <string>//头文件
using namespace std; 
string str1;//声明string对象str1，值为空
string subject="math";//声明string对象 subject，并使用字符串常量进行初始化
string str2=subject;//声明string 对象str2

int main(int argc, char** argv) {
	cout<<"str1="<<str1<<",subject="<<subject<<endl;
	cout<<"str2="<<str2<<endl; 
	return 0;
}

此外，还可以使用字符数组对string 变量进行初始化：

char name[]="程序设计";

stirng c1=name;

还可以声明一个string 对象数组，也就是数组中每个元素都是字符串：

string subject[]={"Math","Chinese","English"};

cout<<subject[1]<<endl;//输出为 Chinese

cout<<sizeof(subject)/sizeof(stirng)<<endl;//输出数组元素的个数：sizeof（subject）是整个数组占用的空间大小，sizeof（string）是每个 string 对象的大小。

2：string对象的操作和使用

string 对象可以用cin 和 cout 进行输入和输出，也可以相互之间互赋值，或者是用字符串常量和字符数组的名字进行赋值。

代码举例


int main()
{
	string s1,s2;
	s1 ="C++程序设计"; 
	s2=s1;
	string s3;
	cout<<"s3="<<s3<<endl;
	s3=s1+s2;
	cout<<"这时s3="<<s3<<endl;
	s3 +="de";
	cout<<"这里s3=" <<s3<<endl;
	
	bool b=s1<s3;  
	cout<<"bool="<<b<<endl;//已声明s1<s3，故输出bool是true，也就是1 
	char c=s1[2];//这里把s2看作一个数组，数组下标从0开始，则数组“c++程序设计”中下标为2的是“+” 
	cout<<"c="<<c<<endl;
	cout<<"数组s1="<<s1<<endl;
	char arrstr[]="Hello";
	s3=s1+arrstr;//+表示连接符 
	cout<<s3<<endl;
	return 0;
}

运行结果

3：string 对象用法示例

string 类中为字符串提供了一些成员函数，利用这些成员函数可以方便实现一些功能，调用方式：

string 对象名. 成员函数名（参数);

一些string类中常用的成员函数：

函数	功能
const char *c_str() const	返回一个指向字符串的指针，字符串内容与本 string 串相同，用于将string转换为 const char *
int size() const;	返回当前字符串的大小
int length() const;	返回当前字符串的长度
bool empty() const;	判断当前字符串是否为空
size_type find( const char *str,size_type index);	返回字符 str 在字符串中第一次出现的位置（从index 进行查找），如果不存在则返回-1
size_type find(char ch,size_type index);	返回字符 ch 在字符串中第一次出现的位置（从index 进行查找），如果不存在返回-1
string &insert(int p,const string &s);	在 p 位置插入字符串 s
string &append(const char *s);	将字符串s 连接到当前字符串的结尾处
string substr(int pos=0,int n =npos) const;	返回从pos开始的n个字符所组成的字符串

代码示例1

#include <iostream>
#include <string.h> 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;
int main(int argc, char** argv) {
	string str;
	if(str.empty())
		cout<<"str is null"<<",length="<<str.length()<<endl;
	else
		cout<<"str is not null"<<endl;
		str=str.append("abcdefg");
		cout<<"str is "<<str<<",size="<<str.size()<<endl;
		const char*p=str.c_str();
		cout<<"p="<<p<<endl;
		cout<<"find:"<<str.find("de",0)<<endl;//从零开始找，查找成功 
		cout<<"find:"<<str.find("de",4)<<endl;//从4开始查找，查找失败 ，下标为4是字母e，不能查找出de。只要是在d前面的字母开始查找，也就是在0--3这个范围进行查找均可查找成功，若超过这个范围就查找失败 。 
		string str1=str.insert(1,"123");//在下标1前面插入 ，也就是在下标为1 的 b前面插入 
		cout<<str1<<endl;
	return 0;
}

运行结果

示例2

#include <iostream>
#include <cstring> //在该程序中我们用到了strcpy（）函数，因此它包含在头文件 cstring中，因此要在程序中使用“#include <cstring> ”
using namespace std;
int main()
{
	string s1="c++程序设计";//一个汉字的长度是2 
	string s2="c++语言" ;
	string s3=s1+s2;
	string s4;
	s4=s1.append(s2);//将s1连接到s2结尾处 
	if(s3==s4)cout<<"结果相同"<<endl;
	else cout<<"结果不相同 "<<endl; 
	int size=s1.size();
	int length=s1.length();
	cout<<"s1 size="<<s1.size()<<",s1 length="<<s1.length()<<endl;//这里 s1 的长度是将 s1和s2连接到一块的总长度，函数size（） 和 length（）都是返回数组长度 
	s1[0]='a';//此时 s1是“a++程序设计”，将s1的第一个字母改为a ，则输出的s1就不再是c++程序设计 
	string s5=s1.substr(3,4);//表示返回从第3个字符，长度为4的子串赋值给s5 ，也就是 程序
	char str[20];//声明一个数组str，长度是20 
	strcpy(str,s5.c_str());//将s5中的字符串复制到str中（C++提供strcpy此类函数，为了对指针操作更加安全，避免内存泄露等异常状态的发生。）
	cout<<"s5="<<s5<<endl;
	cout<<"str="<<str<<endl;
	cout<<"s1="<<s1<<",s2="<<s2<<endl;
	cout<<"s4="<<s4<<endl;
	s1.swap(s2);//函数swap（）表示交换，即将数组 s1和数组s2 进行交换 
	cout<<"此时s1="<<s1<<",s2="<<s2<<endl;
	cout<<"str="<<str<<endl;
	cout<<"s2=" <<s2<<endl;
	cout<<s2.find(str)<<endl; //表示在s2中查找str，str代表的是 程序，也就是说在s2数组中查找 程序 
	return 0;
}

运行结果

总结

以上就是这篇文章给大家带来的知识点了，看到这里相信多多少少都会有些收获，接下来的文章还会给大家带来更多有关c++的东西，期待和大家进行交流。笔耕不息，生命不止~

如有不足，请指正，感谢！

C++学习——共勉（一）

前言

一：简单介绍

二：基本的输入和输出

1：认识相关函数

2：代码示例

3：运行结果

4：注意事项

三：头文件和命名空间

四：强制类型转换运算符

1：代码示例

2：程序解释

五：函数参数的默认值

代码示例

1：注意事项

2：简单举例

六：引用和函数参数的传递

1：什么是引用

2：常引用和普通引用

代码示例

4：传值和传引用

代码示例

七：const 与指针共同使用

代码示例

八：函数重载

代码示例

注意事项

九：指针和动态内存分配

1：指针

2：动态分配

十：用string 对象处理字符串

1：string 对象的声明

2：string对象的操作和使用

代码举例

3：string 对象用法示例

代码示例1

示例2

总结

猜你喜欢