【C/C++学院】0729-语音识别/Const关键字/字符串应用/内存分配以及处理海量数据



语音识别

er.xml

<?xml version="1.0" encoding="utf-8"?>
<GRAMMAR LANGID="804">
  <DEFINE>
    <ID NAME="CMD" VAL="10"/>
    </DEFINE>
  <RULE NAME="COMMAND" ID="CMD" TOPLEVEL="ACTIVE">
    <L>
      <P>资源管理器</P>
      <P>打开企鹅</P>
      <P>关闭企鹅</P>
      <P>关机</P>
      <P>重启</P>
      <P>记事本</P>
      <P>计算器</P>
      <P>画图板</P>
     <P>谭胜</P>
      </L>
    </RULE>
  </GRAMMAR>

yuyin.cpp

#include <windows.h>
#include <atlstr.h>
#include <sphelper.h>
#include <sapi.h>
#include<comutil.h>
#include<string.h>
#include<stdlib.h>

#pragma comment(lib,"sapi.lib")
#pragma comment(lib, "comsupp.lib") 

#define GID_CMD_GR 333333
#define WM_RECOEVENT WM_USER+1

 LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);

 char 	 szAppName[] = "TsinghuaYincheng";
 BOOL b_initSR;
 BOOL b_Cmd_Grammar;
 CComPtr<ISpRecoContext>m_cpRecoCtxt;  //语音识别程序接口
 CComPtr<ISpRecoGrammar>m_cpCmdGramma; //识别语法
 CComPtr<ISpRecognizer>m_cpRecoEngine; //语音识别引擎

 int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iCmdShow)
 {
	 HWND        hwnd;
	 MSG         msg;
	 WNDCLASS    wndclass;

	 wndclass.cbClsExtra          =0;
	 wndclass.cbWndExtra          =0;
	 wndclass.hbrBackground       =(HBRUSH)GetStockObject(WHITE_BRUSH);
	 wndclass.hCursor             =LoadCursor(NULL,IDC_ARROW);
	 wndclass.hIcon               =LoadIcon(NULL,IDI_APPLICATION);
	 wndclass.hInstance           =hInstance;
	 wndclass.lpfnWndProc         =WndProc;
	 wndclass.lpszClassName       =szAppName;
	 wndclass.lpszMenuName        =NULL;
	 wndclass.style               =CS_HREDRAW|CS_VREDRAW;

	 if(!RegisterClass(&wndclass))
	 {
		 MessageBox(NULL,TEXT("This program requires Windows NT!"),szAppName,MB_ICONERROR);
		 return 0;
	 }

	 hwnd=CreateWindow(szAppName,
		               TEXT("传智播客C/C++学院语音识别教程"),
					   WS_OVERLAPPEDWINDOW,
					   CW_USEDEFAULT,
					   CW_USEDEFAULT,
					   CW_USEDEFAULT,
					   CW_USEDEFAULT,
					   NULL,
					   NULL,
					   hInstance,
					   NULL);

	 ShowWindow(hwnd,iCmdShow);
	 UpdateWindow(hwnd);

	 while(GetMessage(&msg,NULL,0,0))
	 {
		 TranslateMessage(&msg);
		 DispatchMessage(&msg);
	 }
	 return msg.wParam;
 }

 LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
 {
	 HDC           hdc;
	 PAINTSTRUCT   ps;

	 switch(message)
	 {
	 case WM_CREATE:
		 {
			 //初始化COM端口
			 ::CoInitializeEx(NULL,COINIT_APARTMENTTHREADED);
			 //创建识别引擎COM实例为共享型
			 HRESULT hr=m_cpRecoEngine.CoCreateInstance(CLSID_SpSharedRecognizer);
			 //创建识别上下文接口
			 if(SUCCEEDED(hr))
			 {
				 hr=m_cpRecoEngine->CreateRecoContext(&m_cpRecoCtxt);
			 }
			 else MessageBox(hwnd,TEXT("error1"),TEXT("error"),S_OK);
			 //设置识别消息,使计算机时刻监听语音消息
			 if(SUCCEEDED(hr))
			 {
				 hr=m_cpRecoCtxt->SetNotifyWindowMessage(hwnd,WM_RECOEVENT,0,0);
			 }
			 else MessageBox(hwnd,TEXT("error2"),TEXT("error"),S_OK);
			 //设置我们感兴趣的事件
			 if(SUCCEEDED(hr))
			 {
				 ULONGLONG ullMyEvents=SPFEI(SPEI_SOUND_START)|SPFEI(SPEI_RECOGNITION)|SPFEI(SPEI_SOUND_END);
				 hr=m_cpRecoCtxt->SetInterest(ullMyEvents,ullMyEvents);
			 }
			 else MessageBox(hwnd,TEXT("error3"),TEXT("error"),S_OK);
			 //创建语法规则
			 b_Cmd_Grammar=TRUE;
			 if(FAILED(hr))
			 {
				 MessageBox(hwnd,TEXT("error4"),TEXT("error"),S_OK);
			 }
			 hr=m_cpRecoCtxt->CreateGrammar(GID_CMD_GR,&m_cpCmdGramma);
			 WCHAR wszXMLFile[20]=L"yuyinliebiao.xml";
			 MultiByteToWideChar(CP_ACP,0,(LPCSTR)"yuyinliebiao.xml",-1,wszXMLFile,256);
			 hr=m_cpCmdGramma->LoadCmdFromFile(wszXMLFile,SPLO_DYNAMIC);
			 if(FAILED(hr))
			 {
				 MessageBox(hwnd,TEXT("error5"),TEXT("error"),S_OK);
			 }
			 b_initSR=TRUE;
			 //在开始识别时，激活语法进行识别
		     hr=m_cpCmdGramma->SetRuleState(NULL,NULL,SPRS_ACTIVE);
	    	 return 0;
		 }
	 case WM_RECOEVENT:
		 {
			 RECT rect;
             GetClientRect(hwnd,&rect);
             hdc=GetDC(hwnd);
			 USES_CONVERSION;
			 CSpEvent event;
			 while(event.GetFrom(m_cpRecoCtxt)==S_OK)
			 {
			     switch(event.eEventId)
			     {
			     case SPEI_RECOGNITION:
    				 {
            			 static const WCHAR wszUnrecognized[]=L"<Unrecognized>";
		            	 CSpDynamicString dstrText;
			    		 //取得识别结果
				    	 if(FAILED(event.RecoResult()->GetText(SP_GETWHOLEPHRASE,SP_GETWHOLEPHRASE,TRUE,&dstrText,NULL)))
					     {
						     dstrText=wszUnrecognized;
    					 }
        	    		 BSTR SRout;
	        	    	 dstrText.CopyToBSTR(&SRout);
						 char* lpszText2 = _com_util::ConvertBSTRToString(SRout);

			    		 if(b_Cmd_Grammar)
				    	 {
							 if (strstr("资源管理器",lpszText2)!=NULL)
	    				     {    

								  system("C:\\");

				        		  DrawText(hdc,TEXT("资源管理器"),-1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
					         }
							  if (strstr("打开企鹅",lpszText2)!=NULL)
	    				     {    

								  system("\"C:\\Program Files\\Tencent\\QQ\\QQProtect\\Bin\\QQProtect.exe\"");
				        		  DrawText(hdc,TEXT("打开企鹅"),-1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
					         }
							  if (strstr("关闭企鹅", lpszText2) != NULL)
							  {
								  system("taskkill /f /im QQ.exe");
								  DrawText(hdc, TEXT("关闭企鹅"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
							  }
							  if (strstr("关机", lpszText2) != NULL)
							  {
								  system("shutdown -s -t 1200");
								  DrawText(hdc, TEXT("关机"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
							  }
							  if (strstr("重启", lpszText2) != NULL)
							  {
								  system("shutdown -r -t 1200");
								  DrawText(hdc, TEXT("重启"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
							  }
							  if (strstr("记事本", lpszText2) != NULL)
							  {
								  system("notepad");
								  DrawText(hdc, TEXT("记事本"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
							  }
							  if (strstr("计算器", lpszText2) != NULL)
							  {
								  system("calc");
								  DrawText(hdc, TEXT("计算器"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
							  }
							  if (strstr("画图板", lpszText2) != NULL)
							  {
								  system("mspaint");
								  DrawText(hdc, TEXT("画图板"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
							  }
							  if (strstr("谭胜", lpszText2) != NULL)
							  {

								  DrawText(hdc, TEXT("这是一个猥琐男"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
							  }

    					 }
        			 }
	    		 }
			 }
			 return TRUE;
		 }
	 case WM_PAINT:
		 hdc=BeginPaint(hwnd,&ps);
		 EndPaint(hwnd,&ps);
		 return 0;
	 case WM_DESTROY:
		 PostQuitMessage(0);
		 return 0;
	 }
	 return DefWindowProc(hwnd,message,wParam,lParam);
 }

Const关键字

Const int *p; int const *p;

const *地址不可以修改

int *const p;

*const指向的数据不可修改

#include <stdio.h>

void main01()
{
	int num = 10;
	//const int data;
	//data = 20;
	const int data = 20;//const 修饰的变量，只能在初始化的时候进行赋值操作
	getchar();
}

//const在*左侧，地址本身不可以修改，可以改变指针指向。只能读不能写
void main02()
{
	int num = 10;
	const int data = 20;
	//const int *p;//等价于int const *p;
	int const *p;
	p = #
	printf("%d\n", *p);
	p = &data;
	printf("%d\n", *p);
	//*p = 30;//

	getchar();
}
//const在*右侧，指向的数据不可修改
void main()
{
	int num = 10;
	const int data = 20;
	int *const p = #//只能在初始化的时候，指定唯一的指向

	//int *const p;
	//p = #
	printf("%d\n", *p);
	//p = &data;
	*p = 30;
	printf("%d\n", *p);
	getchar();
}

void main04()
{
	int num = 10;
	const int data = 20;
	const int *const p = #
	printf("%d\n", *p);
	//*p = 30;
	//p = &data;

	getchar();
}

字符串应用

#define  _CRT_SECURE_NO_WARNINGS //关闭安全检查
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <Windows.h>

void main1()
{
	//char str[100] = "for /l %i in (1,1,5) do calc";
	//char *p = "for /l %i in (1,1,5) do calc";
	//str[0] = ' '; str是数组，存储的是字符串每一个字符
	//*p = ' ';p是一个指针，存储字符串的地址

	char str[100] = { 0 };
	//printf("for /l %%i in (1,1,%d) do %s",5,"calc");
	int num;
	char op[30] = { 0 };
	scanf("%d%s", &num, op);
	sprintf(str, "for /l %%i in (1,1,%d) do %s", num, op);
	system(str);

	system("pause");
}

void main2()
{
	char str[100] = { 0 };
	char op[30] = { 0 };
	scanf("%s", op);
	sprintf(str, "taskkill /f /im %s", op);
	system(str);

	system("pause");
}

void main3()
{
	system("tasklist");
	for (int i = 0x0; i <= 0xf; i++)
	{
		char str[30] = { 0 };//存储指令
		sprintf(str, "color %x%x", i,0xf-i);//打印指令
		system(str);//变色
		Sleep(500);
	}
}

void  main4()
{
	char str[100] = "我有1000元";
	int num;
	sscanf(str, "我有%d元", &num);
	printf("%d", num);

	system("pause");
}

void main5()
{
	//printf("%.6s\n", "1234.abcd");
	char str[100] = "notepad8888";
	char newstr[100] = "";
	sprintf(newstr, "%.s", str);
	system(newstr);

	system("pause");
}

void  main6()
{
	char str1[100] = "note";
	char str2[100] = "pad";
	//system(str1 + str2);
	char str3[100] = { 0 };
	sprintf(str3, "%s%s", str1, str2);//字符串相加
	system(str3);
}

void main7()
{
	//printf("%.6s", "1234.abcd");
	char str[100] = "notepad8888";
	char newstr[100] = "";
	sprintf(newstr, "%-10.7s", str);//10宽度，+宽度范围内右边对齐，-左边对齐，.7从左往右挖去7个字符
	printf("[%s]", newstr);
	system(newstr);

	system("pause");
}

int mystrlen(char* str)
{
	int i = 0;
	for (char*p = str; *p != '\0'; p++)
	{
		i++;
	}
	return i;//实现字符串统计
}

int mystrlenA(char* str)
{
	char *p = str;
	int i = 0;
AAA: if (*p!='\0')
{
		 i++;
		 p++;
		 goto AAA;
}
	 return i;
}

int mystrlenB(char *str)
{
	if (*str=='\0')
	{
		return 0;
	}
	else
	{
		return 1 + mystrlenB(++str);
	}
}

void  main8()
{
	char str[100] = "china is good";
	printf("%d", sizeof(str));//求数组缓冲区长度
	printf("\n%d", mystrlen(str));//从开头第一个字符到\0字符
	printf("\n%d", mystrlenA(str));//从开头第一个字符到\0字符
	printf("\n%d", mystrlenB(str));//从开头第一个字符到\0字符
	getchar();
}

void main9()
{
	char str1[100] = "my name is yincheng";
	char str2[30] = "chen";
	char *p = strstr(str1, str2);
	if (p == NULL)
	{
		printf("没有找到");
	}
	else
	{
		printf("找到%p,%c, %s", p, *p, p);
	}
	getchar();
}

内存分配以及处理海量数据

#include<stdio.h>
#include<stdlib.h>

// m, n生成一个数组，m行 n列
void main()
{
	int *p =(int*) malloc(sizeof(int)* 40);//一维数组
	for (int *px = p,i=0; px < p + 40; px++,i++)//
	{
		*px = i;//赋值
		printf("%d,%p\n", *px, px);//指针循环
	}
	//int b[5][8];
	printf("\n\n\n");
	int(*pp)[8] = (int(*)[8]) p;//指针类型决定了访问的方式
	for (int i = 0; i < 5; i++)
	{
		for (int j = 0; j < 8; j++)
		{
			//printf("%5d", pp[i][j]);//打印数据
			printf("%5d", *(*(pp + i) + j));// pp[i][j]
		}
		printf("\n");
	}
	//a [4][2][5]
	printf("\n\n\n");
	int(*ppp)[2][5] = (int(*)[2][5])p;
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 2; j++)
		{
			for (int k = 0; k < 5; k++)
			{
				//printf("%5d", ppp[i][j][k]);//打印元素
				printf("%5d", *(*(*(ppp + i) + j) + k));
			}
			printf("\n");
		}
		printf("\n\n\n");
	}

	system("pause");
}

#define  _CRT_SECURE_NO_WARNINGS //关闭安全检查
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char **pp=NULL;//存储指针数组的地址

//13180807 *4  /1024/1024  50M

void initdatatomem(char *path)
{
    pp  = (char **)malloc(sizeof(char *)* 13180807);//分配指针数组
	FILE *pf = fopen(path, "r");
	if (pf == NULL)
	{
		printf("fail");
	}
	else
	{
		for (int i = 0; i < 13180807; i++)
		{
			char str[275] = {0};//读取字符串的缓冲区
			fgets(str, 275, pf);//从文件中逐行读取字符串
			int  strlength = strlen(str) + 1;//获取要分配的字符串长度
			char *px =(char *) malloc(sizeof(char)*strlength);//分配内存
			strcpy(px, str);//拷贝字符串
			px[strlength - 1] = '\0';//设定最后一个字符为'\0'
			pp[i] = px;//存储字符串的首地址到指针数组
		}
	}
	printf("载入内存OK\n");
}

void  findstr(char *searchstr)
{
	for (int i = 0; i < 13180807; i++)
	{
		//pp[i];//是一个指针
		char *ptemp = strstr(pp[i], searchstr);//遍历所有的指针数组的地址，字符串查找
		if (ptemp != NULL)
		{
			printf("\n%s", pp[i]);//打印字符串
		}
	}
}

int getfilesize(char *path)
{
	FILE *pf;//文件指针
	pf = fopen(path, "r");//读取的模式打开
	if (pf == NULL)
	{
		return -1;//代表获取失败
	}
	else
	{
		fseek(pf, 0, SEEK_END);//到文件末尾
		int num = ftell(pf);//文件开头到当前位置有多少个字节
		fclose(pf);//关闭文件
		return num;
	}
}

int getn(char *path)
{
	FILE *pf;//文件指针
	pf = fopen(path, "r");//读取的模式打开
	if (pf == NULL)
	{
		return -1;//代表获取失败
	}
	else
	{
		int i = 0;
		while (!feof(pf))//是否到文件末尾
		{
			char str[275];
			fgets(str, 275, pf);//读取一行
			i++;//统计行数
		}
		fclose(pf);//关闭文件
		return i;
	}
}

void main()
{
	/*char *path = "C:\\Users\\yincheng01\\Desktop\\old\\dangdangwang.txt";
	int num = getfilesize(path);
	printf("%d字节，%fK,%fM", num, num / 1024.0, num / 1024.0 / 1024.0);
	printf("\n有%d行", getn(path));*/
	char *path = "C:\\Users\\yincheng01\\Desktop\\old\\dangdangwang.txt";
	initdatatomem(path);
	while (1)
	{
		char searchstr[100] = { 0 };
		scanf("%s", searchstr);
		findstr(searchstr);
	}
	system("pause");
}

版权声明：本博客所有文章均为原创，欢迎交流，欢迎转载；转载请勿篡改内容，并且注明出处，谢谢！

时间： 2024-10-05 05:01:59

【C/C++学院】0729-语音识别/Const关键字/字符串应用/内存分配以及处理海量数据的相关文章

C#中字符串的内存分配与驻留池

刚开始学习C#的时候,就听说CLR对于String类有一种特别的内存管理机制:有时候,明明声明了两个String类的对象,但是他们偏偏却指向同一个实例.如下: String s1 = "Hello";String s2 = "Hello"; //s2和s1的实际值都是"Hello"bool same = (object) s1 == (object) s2; //这里比较s1.s2是否引用了同一个对象实例 //所以不能写作bool same =

字符串相加 内存分配

问题: String s = "a" + "b" + "c";      这里,我们先不考虑"a","b","c"是放置在池中这个问题.      这个"+"操作符,java到底是怎么对待的? 一种说法是"a"是一个字符串对象,+"b"之后,又生成一个字符串对象,大概是"ab",+"c"之

C++中关于const关键字的使用

const关键字用于表示变量或函数, 亦或其他类型的数据其值或其本身的值禁止被修改. 但需要注意的是, 即使被修饰为const类型的变量, 其本质依旧是个变量, 而不是常量. 也许你会说, 这有什么区别呢? 我在代码中感觉不出差别啊. 其实它们的差别在于编译器的编译. 对于编译器来说, 变量意味着需要分配内存空间, 而常量只是在编译期间记录在编译器的一张内存表里面的一个证整数而已.  变量的值必须初始化, 除非使用extern修饰它, 这就告诉编译器该变量是一个全局const变量, 在哪里定义编

readonly const关键字

readonly 关键字与 const 关键字不同. const 字段只能在该字段的声明中初始化. readonly 字段可以在声明或构造函数中初始化. 因此,根据所使用的构造函数,readonly 字段可能具有不同的值. 另外,const 字段为编译时常数,而 readonly 字段可用于运行时常数,如下例所示: public static readonly uint timeStamp = (uint)DateTime.Now.Ticks; // 运行时的时间赋值给static readon

C与C++的const关键字

之所以要谈const,大概就是被const出现的各种位置搞得头晕目眩了罢. (一)C语言中的const关键字 C语言中const修饰的变量或对象的值不能更改. 比如定义const int i = 0;(或int const i = 0;)那么之后任何对i进行改变的操作都会报错. 当然可以投机取巧地去修改const类型的值,比如取得i的指针然后对指针进行操作 const int i = 0; int * p = &i; *p = 3; const也可以修饰指针类型,这就产生了比较麻烦的情况,那就是

C++中const关键字的使用总结

C++中使用const关键字来修饰常量,下面从两个方面总结:变量和成员函数. 变量:const可以修饰普通变量.指针(数组)和结构体. 1.const修饰普通变量是最简单的情形.这样的用法多为在程序中创建一个只读变量,类似于C语言的#define宏定义,但const声明的变量可以指定类型,因此在C++中提倡使用const关键字声明只读变量. const int Month = 12; /* 示例代码 1 */ 示例代码1表示:定义了一个int型变量Month,程序可以使用该变量,但不可对Mont

C/C++中const关键字的用法及其与宏定义的比较

1.const关键字的性质 简单来说:const关键字修饰的变量具有常属性. 即它所修饰的变量不能被修改. 2.修饰局部变量 1 const int a = 10; 2 int const b = 20; 这两种写法是等价的,都是表示变量的值不能被改变,需要注意的是,用const修饰变量时,一定要给变量初始化,否则之后就不能再进行赋值了,而且编译器也不允许不赋初值的写法: 在C++中不赋初值的表达一写出来,编译器即报错,且编译不通过. 在C中不赋初值的表达写出来时不报错,编译时只有警告,编译可以

C++const关键字用法

const关键字是C++新引进的关键字,目标是用于定义常量,避免C语言中使用宏定义出现的边际问题,并且const是类型安全的,即const定义的是不可修改值的变量,它是有类型的,但是宏替换只是简单的进行字符串的替换,容易出现边际问题,造成错误.但是const的用法并不仅仅在此,因此整理一下,加深理解 C++const关键字用法

let 和 const 关键字

看了阮老师的ES6入门再加上自己的一些理解整理出的学习笔记 let关键字 跟var相比,不会提升为全局变量,始终是块级作用域{} 注意点: 1: 不能在同一个块级作用域内声明同名变量 2: (如果当前块级作用域内{}内部没有该变量的声明)向上级作用域查找,如果有声明,就只在本块级作用域中查找 let num = 1;if(true){console.log(num) //1} 3: 各个块级作用域内声明的变量是独立使用的,在更小的作用域内可以使用更大作用域的变量 let num =1 ; if(