目录
一、c++项目创建
二、头文件包含
三、c++命令空间
1、创建语法
2、命名空间的作用
3、如何访问
4、命名空间嵌套
5、标准命名std
6、先声明后实现
四、c++输入输出
1、c++输出
2、c++输入
五、c++函数思想
1、内联函数
A、概念
B、内联函数的特点
C、声明内联函数
2、函数重载
A、概念
B、不同参的三个体现
C、综合代码
3、函数缺省
A、概念
B、函数缺省原则
C、综合代码
六、c++起别名与类型转换
1、c++起别名
2、类型转换
3、c++const
七、c++新数据类型
1、c++bool类型
2、c++指针
3、c++引用类型
A、基本用法
B、左值使用
C、函数参数使用
D、常用引用
E、右值引用
F、指针引用
4、c++auto类型
5、c++结构体
A、基础
B、预备
C、类型不需要struct
D、c++结构体允许存在函数
E、修改数据
六、c++动态内存申请
1、申请单个内存
2、申请一段内存
3、二维数组
4、结构体
七、c++string
1、基本（创建）
2、基本使用
3、string中函数使用
一、c++项目创建
添加的源文件是.cpp文件
二、头文件包含
- c++兼容c语言头文件
- c++自己写的头文件依旧按c语言头文件方式包含
#include“xxx.h” - c++可以去掉.h方式包含c语言的标准库头文件，需要在前面加上c
#include<stdio.h>-> #include<cstdio>
4. c++标准头文件#include<iostream>
三、c++命令空间
1、创建语法
namespace 空间名
{
}
- 空间名随便起
- 存放代码的空间
2、命名空间的作用
- 提高标识符使用率
- 避免命名污染 -> 不同模块名字冲突
3、如何访问
//1.直接访问
空间名::变量名；
//2.省略前置访问
using namespace 空间名；
注意：
1. 这个语法语句有一定的作用域
2.::叫做作用分辨符：可以用来区分全局变量 使用这个语法时候一定要自己避免二义性问题
int gent;//全局变量
cout>>::gent;
//不做区分会采用就近原则
4、命名空间嵌套
剥洋葱
namespace A
{
int a=1;
namespace B
{
int b=12;
namespace C
{
int c=123;
}
}
}
A::B::C:c//剥洋葱即可
也可以using namespace A::B::C
这样可以直接用c进行访问
5、标准命名std
c++使用的东西都是在std这个命名空间中，如果写c++程序，大家没加using namespace std；所有的东西都要加std::前置
#include<iostream>
using namespace std; //标准命名空间
int main()
{
return 0;
}
6、先声明后实现
#include<iostream>
using namespace std;
//先声明
namespace mm
{
void print();
struct Girl;
}
//外面使用需要空间名做限定
void mm::print()
{
cout<<"zhangkai"<<endl;
}
struct mm::Girl
{
char name[20];
int age;
}
int main()
{
struct mm::Girl girl={"zhangsan",19};
mm::print();
//声明需要空间名限定，使用变量成员不需要
cout<<girl.name<<"\t"<<girl.age<<endl;
return 0;
}
四、c++输入输出
1、c++输出
1. c++输出由cout加上<<完成
2. c++依旧支持c语言的转义字符
3. c++换行可以用endl
//精度暂时不用管，流操作符会讲 IO流中会讲
cout <<"fdsf"<<1<<1.33<<endl; //打印常量
int a=1;
char b='s';
char str[]="safgsdg";
cout<<a<<b<<str<<endl; //打印变量
2、c++输入
- c++输入由cin加上>>完成
- c++输入的过程不需要任何其他东西，默认用空格充当数据间隔
int a;
char b;
char str[10]=" ";
cin>>a>>b>>str;
、c++函数思想
1、内联函数
A、概念
内联函数就是编译完成函数的存储形式是二进制形式，是一种牺牲空间的方式提升运行效率
B、内联函数的特点
- 短小精悍
- 重复使用
- 在结构体中或者类中实现的函数默认为内联函数
C、声明内联函数
inline int Max(int a,int b)
{
return a>b?a:b;
}
2、函数重载
A、概念
c++允许存在相同函数名不同参数的函数存在（和参数返回值一点关系都没有）
B、不同参的三个体现
- 参数的数目不同
- 参数的类型不同
- 参数的顺序不同（建立在类型不同的基础上）
C、综合代码
void print(int a,int b)
{
cout<<a+b<<endl;
}
void print(char a,char b)
{
cout<<a+b<<endl;
}
void print(int a,int b,int c)
{
cout<<a+b+c<<endl;
}
//顺序不同
void print(double a,int b)
{
cout<<"顺序不同"<<endl;
}
3、函数缺省
A、概念
函数缺省就是给函数形参默认初始化，就是给形参赋初始值。如果不传参，使用默认参数
B、函数缺省原则
只能从右往左缺省，之间不能存在空的
传参的时候从左往右赋值，没有的使用默认参数
多文件中，.h声明函数缺省即可，实现文件不需要缺省，否者视为重定义
C、综合代码
int sum(int a=0.int b=0,int c=0,int d=0)
{
return a+b+c+d;
}
int main()
{
cout<<sum()<<endl;//a=0,b=0,c=0,d=0;
cout<<sum(1,2)<<endl;//a=1,b=2,c=0,d=0;
}
六、c++起别名与类型转换
1、c++起别名
int Max(int a,int b)
{
return a>b?a:b;
}
using 整数=int；
整数 b=12;
using Func=int(*)(int,int);
Func func=Max;
cout<<func(1,5)<<endl;
2、类型转换
//默认转换依旧不变，支持
int a=1.33;
int b='a';
//强制转换
int result=1/double(2);//c++写法
//专业更为安全的转换
//sratic_cast<要转换的类型>(要转换的表达式)---->等效强制转换
int data=static_cast<int>(1.33);
data=int("zhangkai");//老写法不会报错，static_cast会报错
3、c++const
char* str="zhangkai";错误，c++要求更加严格
应该加上const,const char* str="zhangkai";
void print(char* str)
{
cout<<str<<endl;
}
//print("hkdsfjf");函数参数不能传入常量
将 char* str改为 const char* str
//不能用 static_cast去掉const属性
//const_cast专门用来操作const属性
printf(const_cast<char*>("fadsgsf"));
//dynamic_cast 多态中的转换
七、c++新数据类型
1、c++bool类型
//不用包含头文件
//基本用法
bool num=false;
num=true;
cout<<num<<endl;
//计算机非零值表成立
num=123;
cout<<num<<endl;
//占用内存,1字节
cout<<sizeof(num)<<endl<<sizeof(bool)<<endl;
//结合流控制字符可以打印false和true
cout<<boolalpha<<num<<endl;
2、c++指针
空指针的写法，c++新标准引入新的关键字描述：nullptr
int* p=nullptr;
void* p2=nullptr;
3、c++引用类型
A、基本用法
//基本用法---->理解为别名
int 女朋友=111;
int& 小可爱=女朋友;
小可爱=888;
cout<<女朋友<<endl;//此时女朋友的值为888
B、左值使用
//充当函数返回值，增加左值使用
//注意：不能局部变量的引用
int g_num=12;
//返回引用类型等效返回变量本身
int& returnValue()
{
return g_num;
}
returnValue()=1234;
//returnValue()与g_num是一个东西
cout<<g_num<<endl;
C、函数参数使用
//充当函数参数，防止拷贝本产生
void modify2(int& a) //int& a=实参
{
a=1001;
}
int num=100;
modify2(100);//c++引用不是指针,传参传变量即可
cout<<endl<<num<<endl;
D、常用引用
const int num=11;
//int& c=num; //错误
const int& c=num;
E、右值引用
int&& girl=11;//右值引用-->新语法--->规则
//专为常量起别名
void print(const int& a)
{
a=1111;//错误，无法修改
}
void print1(int&& a)
{
a=1111;
}
关于右值引用，c++提供了可以把左值变成右值得函数
int data=1234;
int&& data2=move(data);//转交所有权限
data2=234；
cout<<data<<endl;
F、指针引用
int number=123;
int* p=&number; //指针类型：去掉变量名
int* &pp=p;
int number2=11111;
pp=&number2;
cout<<*p<<endl;
4、c++auto类型
auto叫做自动推断类型，一定要有数据作为赋值去推断，才可以使用auto
//auto data;错误，没有推断依据
int num=1;
auto data=num;//自动data为int类型
int Max(int a,int b)
{
return a>b?a:b;
}
auto Func=Max; //自动int(*)(int,int)
cout<<Func(4,5)<<endl;
struct MM
{
int age;
};
struct MM mm={133};
auto PMM=&mm;
cout<<PMM->age<<endl;
auto& Pnum=num;
Pnum=123;
cout<<num<<endl;
5、c++结构体
A、基础
1. c++类能有的东西c++结构体都可以（构造函数、析构函数、继承）
2. 注意：c++结构体一旦写了构造函数,必须要按照类的方式去使用，在没有写构造函数之前和c语言的结构体一样的用法
B、预备
#include<iostream>
using namespace std;
struct MM
{
int age;
int num;
//成员函数
void print()
{
cout<<age<<"\t"<<num<<endl;
}
void setData(int Age,int Num)
{
age=Age;
num=Num;
}
int& getAge()
{
return age;
}
int& getNum()
{
return num;
}
void printData();
};
void MM::printData()
{
cout<<"zhangkai"<<endl;
}
C、类型不需要struct
//类型上得改变，类型不需要struct，结构体名即可
MM mm={100,1001};
cout<<mm.age<<"\t"<<mm.num<<endl;
auto p=&mm;
cout<<p->age<<"\t"<<p->num<<endl;
D、c++结构体允许存在函数
mm.print(); //mm.age mm.num
p->print();
MM girl={200,200};
girl.print(); //girl.age girl.num
E、修改数据
//1.直接访问
mm.age=111;
mm.num=1234;
mm.print();
//2.提供成员访问
mm.setData(888,999);
mm.print();
//3.返回引用方式--->c++叫做提供访问接口
mm.getAge()=66;
mm.getNum()=99;
//每一步打印封装成行为
mm.print();
六、c++动态内存申请
c语言内存分为四区，c++分为五区，c语言动态内存申请是堆区，c++里面是自由存储区
c语言是由：malloc，calloc，realloc，free负责内存申请和释放；c++中是由new和delete做内存申请和释放
需要包含头文件#include<new>
1、申请单个内存
void testNewOne()
{
//先在自由存储区创建一个变量，把变量地址返回给p
int* p=new int;
*p=1234;
cout<<*p<<endl;
//申请内存并做初始化
int* pp=new int(1234);
cout<<*pp<<endl;
delete p;
delete pp;
}
2、申请一段内存
void testTwo()
{
//申请一段内存，等效int p[4]
int* p=new int[4];
//申请并初始化
int* pp=new int[4]{1,2,3,4};//{data}叫做数据列表
for(int i=0;i<4;i++)
{
cout<<pp[i]<<"\t";
}
cout<<endl;
delete[] p;
delete[] pp;//代表释放一段内存
}
3、二维数组
int** parry=new int*[3];
for(int i=0;i<3;i++)
{
parry[i]=new int[5];
}
//释放
for(int i=0;i<3;i++)
{
delete[] parry[i];
}
delete[] parry;
int (*pArry)[4]=new int[3][4];
auto P2=new int[3][4];
delete[] pArry;
delete[] p2;
4、结构体
struct MM
{
int age;
int num;
};
void testStruct()
{
MM* p=new MM;
p->age=123;
p->num=1234;
}
七、c++string
c语言的是char*,包含头文件
#include<cstring>或者#include<string.h>，c++的string包含方式是#include<string>
#include<iostream>
#include<string>
#include<cstdio>
using namespace std;
1、基本（创建）
void testcreateString()
{
string str;
str='A';
//string str='A'; //不可以
string str1="asfasf";
cout<<str1<<"\t"<<str<<endl;
//输入
string str2;
cin>>str2;
cout<<str2<<endl;
//1.赋值，把str2的值赋给str3
string str3(str2);
cout<<str3<<endl;
//2.赋值
str3="dfsaf";
str3=str1;
cout<<str3<<endl;
}
2、基本使用
void userString()
{
//比较，直接用运算符比较即可
string a="1234";
string b="123";
cout<<(a<b)<<endl;
cout<<(a>=b)<<endl;
//使用函数
a.compare(b);
//字符串连接
string result=a+b;
//调用函数连接
a.append(b);
cout<<result<<endl;
}
3、string中函数使用
void testStringFunc()
{
//支持下标访问
string str="zhangkai";
for(int i=0;i<str.size();i++)
{
//cout<<str[i];
//等效上面的str[i]
cout<<str.at(i);
}
cout<<endl;
cout<<str.front()<<"第一个\t"<<str.back()<<"最后一个"<<endl;
//别致的访问方式
cout<<*str.begin()<<"str.begin()代表开始的位置"<<endl;
cout<<*(str.begin()+1)<<"第二个元素"<<endl;
//cout<<str.end()<<endl;
//结尾是最后一个元素的后面，不能做*运算
//旧版for循环，迭代器
for(auto m=str.begin();m!=str.end();m++)
{
cout<<*m;
}
cout<<endl;
//c++区间遍历，新版for循环
for(auto v:str)//从str的开始遍历到结尾
{
cout<<v;
}
cout<<endl;
//c++string和c语言的char*有区别,把c++string转换为c语言的char*,eaxyz要求的是char*
string first="sfsdagf";
printf("%s",first.data());
puts(first.c_str());
//c++把数字转换为相应的字符串
string test=to_string(12345);
cout<<test<<endl;
//截断
first="zhangkai";
first.substr(3);
cout<<first<<endl;//不会改变原来的字符串
cout<<first.substr(3)<<endl;
//截取后的结果当做函数的返回值，ngkai
}
————————————————
版权声明：本文为CSDN博主「热爱编程的小K」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_72157449/article/details/128399014
