C++入门02
自动推断类型
主要两种自动推断的类型
-
auto
-
C语言中的auto是一种自动的存储类型，就是系统默认的，在C语言中auto不是很常用，C++做了修改后，auto就在C++中展示了优点 -
使用时一定要初始化，因为auto是根据初始化的值去推断数据的类型 auto j=100; //auto推断出j是整型
double dNum=3.14;
auto k=dNum; //auto推断出k是double类型
auto t; //这样是错误的，auto类型必须初始化
auto a=j+dNum; //这里推断出a是double型，因为int+double->double
-
decltype
-
定义一个变量与某一表达式的类型相同，但并不想用该表达式初始化这个变量，这时我们需要decltype变量 -
使用前必须要存在至少一个的数据类型，才能使用decltype自动推断 int iNum;
decltype(iNum) decNum=3;
//这里就是decNum的类型和iNum的一样的意思 那么decltype(iNum) 就是一个类型
//decltype(要自动推断的变量或表达式) 新的标识符;
double dNum=3.14;
iNum=9;
decltype(dNum+iNum) result;
//这里就不需要管dNum+iNum的结果是什么类型，直接自动推断完事，反正我想要的只是这个结果的类型
获取自动推断类型的关键字
string类的基本用法
在C语言中的字符串都是用字符数组或者是字符指针表示的字符串,但是这样表示 的字符串不能直接相加（需要strcat），不能直接复制（需要strcpy）等功能，因此，C++就创建了一个string类提供这些功能，然后string类就专门来做字符串的工作。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main()
{
char* str = "ILoveyou";
char* str2 = "IMissyou";
strcat(str, str2);
printf("%s\t%s\n", str, str2);
return 0;
}
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main()
{
char str[20] = "ILoveyou";
char str2[10] = "IMissyou";
strcat(str, str2);
printf("%s\t%s\n", str, str2);
return 0;
}
回顾了C语言的代码后开始进入string类的使用，直接当作普通的类型使用。
#include<iostream>
using namespace std;
int main()
{
string str = "ILoveyou";
string str2 = "IMissyou";
str = str + str2; //可以直接相加，也可以直接复制，赋值的时候就存在一个隐式的调用string类中的复制的函数
cout << str << '\t' << str2 << endl;
//输出: ILoveyouIMissyou IMissyou
return 0;
}
相对于C语言的字符数组和字符指针来说string就更加的简单使用，不用考虑溢出什么的。
string str="ILoveyou";
cout << str.length() << endl;
//直接输出字符串的长度:8
//如果是C
char* str2="ILoveyou";
printf("%d\n",strlen(str2)); //8
因为string是一个类，里面还有很多东西，先留个悬念。入门只要掌握string的基本用法就可以了。
C++的结构体和类
在C语言中的结构体可以封装多种基本数据类型，但是不能有函数，在C++中的结构体就添加了结构体中的成员函数的概念。C语言也没有类的概念的，C++中就引出了类的说法，类将是C++的基本单元，后面的面向对象的学习就经常和 类打交道。而C++的结构体和类本质上是一样的，区别仅仅在于默认的权限限定不同，结构体默认的权限是公有性 public，类的默认权限限定是私有性 private
结构体
-
struct 结构体名{}; 跟C语言的结构体定义一样
struct Stu
{
char name[10];
int age;
int num;
};
//C++的结构体
struct Stu
{
string name="C++可以初始化"; //可以初始化
int age=0;
int num; //也可以不初始化
//可以有成员函数
void print()
{
//可以在结构体中直接实现函数
cout<<name<<'\t'<<age<<'\t'<<num<<endl;
}
//也可以在结构体中声明在结构体外实现
void printStu();
//还可以重载
void initData(string name1,int age1)
{
name=name1;
age=age1;
num=1001;
}
//重载initData
void initData(string name1,int age1,int num1)
{
name=name1;
age=age1;
num=num1;
//在结构体中实现的函数叫内联函数
}
};
//结构体外实现的成员函数要加结构体名限定
void Stu::printStu()
{
//name是结构体Stu的name
cout<<name<<endl;
}
-
结构体定义对象（变量）
-
其实对象和变量是差不多的概念，在C++和Java等这些面向对象的编程语言中更喜欢把结构体和类定义出来的变量叫做对象。正所谓面向对象就面向变量编程，给变量封装一系列的操作，使用的时候直接通过变量来操作就好，于是就把变量称为对象就比较符合人类的思维。 -
C语言中使用结构体定义变量时是采用struct 结构体名的方式定义的 struct Stu stu;
-
C++中使用结构体定义变量时，可以保留C的风格，也可以直接使用结构体名的方式定义结构体变量 struct Stu stu; //正确Stu stu2; //也正确
-
结构体的访问 依然是和C语言一样，结构体变量用 . 访问，结构体指针用->访问 //假设现在要访问上面的结构体的成员
//先用结构体定义出一个对象出来
Stu stu;stu.name="HAX"; //对象访问结构体Stu中的name
stu.age=19; //对象访问结构体Stu中的age
stu.num=2020; //对象访问结构体Stu中的num
stu.print(); //对象访问结构体中的print()函数
//创建一个结构体指针
Stu* pstu=&stu;
pstu->printStu(); //指针访问结构体中的printStu()函数
类
class 类名{};
类的东西和结构体是差不多的，仅仅只是默认限定不同
class MM
{
public: //表示以下的代码是公有的属性
string name;
int age;
int num;
//这里是形参缺省的写法
void initData(string name1="",int age1=0,int num1=0);
void print();}; //类的这个地方的分号也是不能少的
//类外实现的函数需要类名限定，如果类中的成员函数采用缺省的写法，在类外实现的时候不写缺省
void MM::initData(string name1,int age1,int num1)
{
name=name1;
age=age1;
num=num1;
}
//inline 修饰的成员函数表示的是内联函数
inline void MM::print()
{
cout<<name<<'\t'<<age<<'\t'<<num<<endl;
}
三种权限限定词
-
公有属性：public
- 表示在public: 之后直到下一个限定词之前的成员都是公有的，类外对象都可以访问得到
-
保护属性：protected
- 表示在protected: 之后直到下一个限定词之前的成员都是被保护的，类外对象不能访问
-
私有属性：private
- 表示在private: 之后直到下一个限定词之前的成员都是私有的，类外对象不能访问
#include<iostream>
using namespace std;
class MM
{
public:
void initData(string name1,int age1,int money1)
{
name = name1;
age = age1;
money = money1;
}
void print()
{
cout << name << '\t' << age << '\t' << money << endl;
}
protected:
string name;
int age;
private:
int money;
};
int main()
{
MM mm;
//这些是错的，因为name,age,money都是类外对象访问不到的
//mm.name = "w";
//mm.age = 0;
//mm.money = 0;
//所以提供一个公有接口用来初始化对象
mm.initData("w", 0, 0);
mm.print();
return 0;
}
类中的数据成员一般称为属性，类中的成员函数一般称为行为 一般类中数据成员都是放在protected限定或者是private限定，而成员函数一般是放在public限定 即属性采用保护限定或私有限定，行为采用公有限定
-
类中不写限定词的地方表示默认限定 -
类种的限定词可以不按顺序写，也可以有多个同种的限定词 class MM
{
//这里不写限定词表示默认限定，类的默认限定是私有属性
public: //公有属性
void print();
protected: //保护属性
int age;
public: //再写一个公有属性
void initData();
private: //私有属性
int money;
protected: //在写一个保护属性
int j;
//类中的所有成员随便写，但是毕竟是面向对象，所以标识符尽量是英文单词组合
};
私有属性和保护属性都是类外对象访问不到的，那它们有什么区别呢？在后面的继承和多态在说它们之间的区别
C++的动态内存申请部分
说到动态内存申请就一定要提到C语言的三个动态内存申请的函数 和一个释放函数,还有一个断言的函数
断言函数和头文件
C语言中
三个动态内存申请的函数
-
malloc
-
calloc
-
直接上代码 #include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int main()
{
int length = 10;
int* p = (int*)calloc(length, sizeof(int));
assert(p);
for (int i = 0; i < length; i++)
{
printf("%d ", p[i]);
}
free(p);
p=NULL;
return 0;
}
-
realloc
-
直接上代码 #include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int main()
{
int length = 10;
int* p = (int*)calloc(length, sizeof(int));
assert(p);
for (int i = 0; i < length; i++)
{
printf("%d ", p[i]);
}
printf("\n");
int*p2 = (int*)realloc(p, 12);
for (int i = 0; i < length+2; i++)
{
printf("%d ", p2[i]);
}
free(p);
p = NULL;
p2 = NULL;
return 0;
}
一个配套的释放函数
C++中
一个动态内存申请关键字:
一个配套的释放关键字:
int*p=new int;
delete p;
int* p2=new int[3];
delete[] p2;
girlFriend* p3=new girlFriend[6];
delete[] p3;
|