1.C++中的结构体
#include<iostream>
struct
lstruct
{
int
num;
};
struct
MyStruct
{
int
num;
double
db = 10.8;//可以有默认的值
//MyStruct sx;//拒绝内部定义自己，也就是说不能够内部指向自己
MyStruct *pnext;
MyStruct *phead;
lstruct
l1;
void
boss()
//可以有方法
{
}
};
struct
MyStructA
{
int
num;
double
db = 10.8;//默认的值
//MyStruct sx;//拒绝内部定义自己
MyStruct *pnext;
MyStruct *phead;
lstruct
l1;
void
boss()
{
}
};
struct
{
int
num;
double
db;//默认的值，不能赋初值，否则编译就会出现错误
MyStruct
boss1;
}sx,
sy;//匿名结构体不允许初始化
void
main()
{
MyStruct
s1;//自动管理
MyStruct *pnew
= new
MyStruct;//手动
s1.l1.num;
//pnew->l1.num;
(*pnew).l1.num;
//类型相同可以整体赋值
//结构体C++风格初始化方式
MyStruct
s2(s1);
MyStruct *pnew2(new
MyStruct);
MyStructA
sa1;
//MyStruct s3(sa1);C++强类型，必须类型匹配
}
void
main1()
{
MyStruct
s1;
std::cout
<< s1.db
<< std::endl;
sx.boss1.num;//结构体嵌套就是...
std::cin.get();
}
2.空类
#include<iostream>
//空类占一个字节，表明类存在
//空类有int,占4个，
class
kong
{
public:
//int num
void
go(int
num)
{
std::cout
<< "锄禾日当午";
}
};
void
main()
{
std::cout
<< sizeof(kong)
<< std::endl;
//
std::cout<< &kong << std::endl;
kong
kong1;
//kong1.num = 10;
std::cout
<< &kong1 <<
std::endl;
std::cin.get();
}
3.C语言管理进程
#define
_CRT_SECURE_NO_WARNINGS
#include
<stdio.h>
#include<string.h>
#include<windows.h>
//面向过程的模式
//代码重用主要靠函数
void
open(const
char *path,
const
int
mode)
{
ShellExecuteA(0,
"open",
path, 0, 0,
mode);
}
void
all()
{
system("tasklist");
}
void
closebyname(const
char *name)
{
char
cmdstr[100] = { 0 };
sprintf(cmdstr,
"taskkill /f/im %s",
name);
system(cmdstr);
}
void
closebypid(const
int
num)
{
char
cmdstr[100] = { 0 };
sprintf(cmdstr,
"taskkill /pid%d",
num);
system(cmdstr);
}
void
main1()
{
all();
open("notepad",
1);
all();
Sleep(2000);
int
num;
scanf("%d",
&num);
closebypid(num);
//closebyname("notepad.exe");
system("pause");
}
struct
fu
{
int
a;
int
b;
};
//a+bi,
struct
fu
add(struct
fu
fu1,
struct
fu
fu2)
{
struct
fu
fu3;
fu3.a
= fu1.a
+ fu2.a;
fu3.b
= fu1.b
+ fu2.b;
return
fu3;
}
void
main3()
{
//数据可以随便被别人，可以随便被修改
struct
fu
fu1 = { 3, 4 };
struct
fu
fu2 = { 13, 4 };
fu1.a
+= 3;
struct
fu
fu3 =
add(fu1,
fu2);
printf("%d+%di",
fu3.a,
fu3.b);
getchar();
}
4.C++面向对象管理进程
#define
_CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include
<windows.h>
//C++类的继承实现代码重用， C重用 函数
//类的封装实现权限，封装，数据与代码合为一体。C封装主要是函数
//封装可以锁定代码的权限，锁定的数据的权限，避免被随意修改
//类的多态，一个接口根据实际需求完成很多不同的功能
class
cmduse
{
private:
char
cmduser[100];//用户名
char
cmd[100];//存储指令
public:
void
setuser(const
char *
name)
{
strcpy(cmduser,
name);
}
char *
getuser()
{
return
this->cmduser;//返回用户名
}
void
open(const
char *path,
const
int
mode)
{
ShellExecuteA(0,
"open",
path, 0, 0,
mode);
}
void
all()
{
system("tasklist");
}
void
closebyname(const
char *name)
{
memset(this->cmd,
0, 100);//清空字符串
sprintf(this->cmd,
"taskkill /f/im %s",
name);
system(this->cmd);
}
void
closebypid(const
int
num)
{
memset(this->cmd,
0, 100);//清空字符串
sprintf(this->cmd,
"taskkill /pid%d",
num);
system(this->cmd);
}
};
void
main2()
{
cmduse
cmduse1;
cmduse1.setuser("yincheng");
std::cout
<< cmduse1.getuser()
<< std::endl;
cmduse1.open("calc",
1);
cmduse1.open("notepad",
0);
Sleep(2000);
cmduse1.all();
cmduse1.closebyname("calc");
int
pid;
std::cin
>> pid;
cmduse1.closebypid(pid);//根据编号关闭
std::cin.get();
std::cin.get();
//closebypid(100);
}
//封装可以实现代码权限，不可以随便调用
class
{
public:
void
seta(int
a)
{
//接口
this->a
= a;
}
int
geta()
{
return
this->a;
}
void
setb(int
b)
{
//接口
this->b
= b;
}
int
getb()
{
return
this->b;
}
protected:
private:
int
a;
int
b;
char
password[100];
}myab;
void
main()
{
//
myab.geta = 3;
myab.seta(10);
//封装解决的问题
//类的，代码与数据，一体化
//代码的封装，限定代码谁可以执行谁不可以执行的权限
//数据的封装，防止数据被意外修改
}
5.C++中的联合体
#include<iostream>
//union
本质也是一个类，可以内部有函数，
//union,内部数据是共享，不同对象之间是独立的，代码是共享
//union,也具备结构体所有功能
//某些节约内存的类需要用到共用体
union
MyUnion
{
int
num;
double
db;
void
go()
{
}
};
//内部数据是共享内存，不可以继承
union
MyUnionA
{
int
num;
double
db;
void
go()
{
}
};
void
main()
{
std::cout
<< sizeof(MyUnion)
<< std::endl;
MyUnion
union1;
//
union1.db = 10;
union1.num
= 20;
std::cout
<< union1.num
<< std::endl;
union1.db
= 10.9;//时时刻刻共用体仅有一个变量存在
std::cout
<< union1.num
<< std::endl;
std::cin.get();
}