c++参数管理

最新推荐文章于 2024-04-29 00:03:48 发布
最新推荐文章于 2024-04-29 00:03:48 发布
阅读量1.2k 收藏
点赞数
分类专栏： C/C++ 文章标签： c 参数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andr0id/article/details/20650833
版权 
/*
 * ArgumentMan.h
 */
#pragma once
#include <map>
#include <vector>
#include <set>
#include <string>
#include <algorithm>
#include <assert.h>
#include <stdlib.h>

#ifdef _MSC_VER
#pragma  warning( push ) 
#pragma warning(disable:4996)
#endif

namespace AM
{
#define TEMPLATE template<class _Str/*=std::string*/, typename _Chr/*=char*/>

	//_Str = std::string || std::wstring, _Chr = char || wchar_t
	template<class _Str = std::string, typename _Chr = char>
	class CArgumentMan
	{
	public:
		CArgumentMan(void);
		virtual ~CArgumentMan(void);

	public:
		//添加命令标识符
		void AddCmdFlag(_Chr cCmdFlag);
		//设置是否多值 bValue==true:-key value1 value2
		void SetMultiValue(bool bValue);
		//设置是否参数标志忽略大小写
		void SetIgnoreCase(bool bValue);
		//解析命令行
		void Parse(int argc, _Chr **argv);
		//重置
		void Reset();

	public://没有参数名的参数值使用 ""(空字符串)作为key 去获取
		//获得参数
		const std::map<_Str, std::vector<_Str>> &GetArgs();
		std::vector<_Str> GetArgs(const _Str &sArgName);
		//获得参数(只获得一个参数)
		_Str GetArg(const _Str &sArgName);
		//判断是否有参数
		bool Has(std::vector<_Str> &vctOutArgs, const _Str &sArgName);
		bool Has(_Str &sOutArg, const _Str &sArgName);

		只能在_Str为std::wstring时可使用//
		//获得参数
		std::map<std::string, std::vector<std::string>> ToAnsiArgs();
		//获得参数
		std::vector<std::string> GetAnsiArgs(const std::string &sArgName);
		//获得参数(只获得一个参数)
		std::string GetAnsiArg(const std::string &sArgName);
		//判断是否有参数
		bool HasAnsi(std::string &sOutArg, const std::string &sArgName);
		bool HasAnsi(std::vector<std::string> &vctOutArgs, const std::string &sArgName);
		//
		只能在_Str为std::string 时可使用//
		//获得参数
		std::map<std::wstring, std::vector<std::wstring>> ToUnicodeArgs();
		//获得参数
		std::vector<std::wstring> GetUnicodeArgs(const std::wstring &sArgName);
		//获得参数(只获得一个参数)
		std::wstring GetUnicodeArg(const std::wstring &sArgName);
		//判断是否有参数
		bool HasUnicode(std::wstring &sOutArg, const std::wstring &sArgName);
		bool HasUnicode(std::vector<std::wstring> &vctOutArgs, const std::wstring &sArgName);
		//

	protected:
		template<class T>
		T& makeName(T& name);

	private:
		std::map<_Str, std::vector<_Str>> m_mapArgument;//命令集合
		std::set<_Chr> m_setCmdFlag;  //名字标志符
		bool m_bMultiValue; //一个参数标志后面是否允许多个值（例如：/F v1 v2 v3）
		bool m_bIgnoreCase; //忽略参数标志大小写
	};

	//

	//unicode 转为 ansi
	bool WideByte2Ansi(std::string &out, const wchar_t* wstrcode)
	{
#if 0
		int ansiSize = ::WideCharToMultiByte(CP_OEMCP, 0, wstrcode, -1, NULL, 0, NULL, NULL);
		if (ansiSize == ERROR_NO_UNICODE_TRANSLATION)
		{
			//throw std::exception("Invalid UTF-8 sequence.");
			return false;
		}
		if (ansiSize == 0)
		{
			//throw std::exception("Error in conversion.");
			return false;
		}

		out.resize(ansiSize, '\0');
		int convresult = ::WideCharToMultiByte(CP_OEMCP, 0, wstrcode, -1, const_cast<char *>(out.c_str()), ansiSize, NULL, NULL);
		if (convresult != ansiSize)
		{
			//throw std::exception("La falla!");
			return false;
		}
		out.resize(strlen(out.c_str()));
#else
		size_t nLen = wcslen(wstrcode) * 2;
		if (nLen == 0)
		{
			out.resize(0);
			return true;
		}

		setlocale(LC_ALL, "zh_CN");
		char* ar = new char[nLen + 1];
		memset(ar, 0, nLen + 1);
		size_t read = wcstombs(ar, wstrcode, nLen);
		out = ar;
		out.resize(read);
		delete[] ar;
		setlocale(LC_ALL, "");
#endif
		return true;
	}

	//ansi 转 Unicode
	bool Ansi2WideByte(std::wstring& out, const char* strAnsi)
	{
#if 0
		int widesize = ::MultiByteToWideChar(CP_ACP, 0, strAnsi, -1, NULL, 0);
		if (widesize == ERROR_NO_UNICODE_TRANSLATION)
		{
			//throw std::exception("Invalid UTF-8 sequence.");
			return false;
		}
		if (widesize == 0)
		{
			//throw std::exception("Error in conversion.");
			return false;
		}

		out.resize(widesize, '\0');
		int convresult = ::MultiByteToWideChar(CP_ACP, 0, strAnsi, -1, const_cast<wchar_t*>(out.c_str()), widesize);
		if (convresult != widesize)
		{
			//throw std::exception("La falla!");
			return false;
		}
		out.resize(wcslen(out.c_str()));
#else
		size_t nLen = strlen(strAnsi) * 2;
		if (nLen == 0)
		{
			out.resize(0);
			return true;
		}

		setlocale(LC_ALL, "zh_CN");
		wchar_t* ar = new wchar_t[nLen + 1];
		memset(ar, 0, nLen + 1);
		size_t read = mbstowcs(ar, strAnsi, nLen);
		out = ar;
		out.resize(read);
		delete[] ar;
		setlocale(LC_ALL, "");
#endif
		return true;
	}

	TEMPLATE
		CArgumentMan<_Str, _Chr>::CArgumentMan(void)
		: m_bMultiValue(false)
		, m_bIgnoreCase(false)
	{
	}

	TEMPLATE
		CArgumentMan<_Str, _Chr>::~CArgumentMan(void)
	{
	}

	TEMPLATE
		template<class T>
	T& AM::CArgumentMan<_Str, _Chr>::makeName(T& name)
	{
		if (m_bIgnoreCase)//是否区别大小写
		{
			transform(name.begin(), name.end(), name.begin(), towupper);//全部转换成大写
		}
		return name;
	}

	TEMPLATE
		void CArgumentMan<_Str, _Chr>::AddCmdFlag(_Chr cCmdFlag)
	{
		m_setCmdFlag.insert(cCmdFlag);
	}

	TEMPLATE
		void CArgumentMan<_Str, _Chr>::SetMultiValue(bool bValue)
	{
		m_bMultiValue = bValue;
	}

	TEMPLATE
		void CArgumentMan<_Str, _Chr>::SetIgnoreCase(bool bValue)
	{
		m_bIgnoreCase = bValue;
	}

	TEMPLATE
		void CArgumentMan<_Str, _Chr>::Parse(int argc, _Chr **argv)
	{
		std::set<_Chr>::iterator itSetEnd = m_setCmdFlag.end();
		std::map<_Str, std::vector<_Str>>::iterator itMapEnd = m_mapArgument.end();

		_Str sLocalCmd;
		for (int i = 0; i < argc; ++i)
		{
			_Str sCmd = argv[i];
			if (m_setCmdFlag.find(sCmd[0]) != itSetEnd)
			{//找到命令标志  
				sCmd.erase(sCmd.begin());
				makeName<_Str>(sCmd);

				std::map<_Str, std::vector<_Str>>::iterator itMapFinder = m_mapArgument.find(sCmd);
				if (itMapFinder == itMapEnd)
				{
					m_mapArgument.insert(std::make_pair(sCmd, std::vector<_Str>()));
				}

				sLocalCmd = sCmd;
			}
			else
			{
				std::map<_Str, std::vector<_Str>>::iterator itMapFinder = m_mapArgument.find(sLocalCmd);
				if (itMapFinder == itMapEnd)
				{
					m_mapArgument.insert(std::make_pair(sLocalCmd, std::vector<_Str>()));
					itMapFinder = m_mapArgument.find(sLocalCmd);
				}
				itMapFinder->second.push_back(sCmd);

				if (!m_bMultiValue)//是否多值
				{
					sLocalCmd.resize(0);
				}
			}
		}

	}

	TEMPLATE
		void CArgumentMan<_Str, _Chr>::Reset()
	{
		m_setCmdFlag.clear();
		m_mapArgument.clear();
	}

	TEMPLATE
		std::vector<_Str> CArgumentMan<_Str, _Chr>::GetArgs(const _Str &sArgName)
	{
		_Str sArgNameUpper = sArgName;
		makeName<_Str>(sArgNameUpper);

		std::map<_Str, std::vector<_Str>>::iterator itMapFinder
			= m_mapArgument.find(sArgNameUpper);
		if (itMapFinder != m_mapArgument.end())
		{
			return itMapFinder->second;
		}

		return std::vector<_Str>();
	}

	TEMPLATE
		const std::map<_Str, std::vector<_Str>> & CArgumentMan<_Str, _Chr>::GetArgs()
	{
		return m_mapArgument;
	}

	TEMPLATE
		_Str CArgumentMan<_Str, _Chr>::GetArg(const _Str &sArgName)
	{
		_Str sArgNameUpper = sArgName;
		makeName<_Str>(sArgNameUpper);

		std::map<_Str, std::vector<_Str>>::iterator itMapFinder
			= m_mapArgument.find(sArgNameUpper);
		if (itMapFinder != m_mapArgument.end())
		{
			return (itMapFinder->second).at(0);
		}

		return _Str();
	}

	TEMPLATE
		bool CArgumentMan<_Str, _Chr>::Has(std::vector<_Str> &vctOutArgs, const _Str &sArgName)
	{
		_Str sArgNameUpper = sArgName;
		makeName<_Str>(sArgNameUpper);

		std::map<_Str, std::vector<_Str>>::iterator itMapFinder
			= m_mapArgument.find(sArgNameUpper);
		if (itMapFinder != m_mapArgument.end())
		{
			vctOutArgs = itMapFinder->second;
			return true;
		}

		return false;
	}

	TEMPLATE
		bool CArgumentMan<_Str, _Chr>::Has(_Str &sOutArg, const _Str &sArgName)
	{
		_Str sArgNameUpper = sArgName;
		makeName<_Str>(sArgNameUpper);

		std::map<_Str, std::vector<_Str>>::iterator itMapFinder
			= m_mapArgument.find(sArgNameUpper);
		if (itMapFinder != m_mapArgument.end())
		{
			if (itMapFinder->second.empty())
			{
				sOutArg.resize(0);
			}
			else
			{
				sOutArg = itMapFinder->second.at(0);
			}
			return true;
		}

		return false;
	}

	TEMPLATE
		std::map<std::string, std::vector<std::string>> AM::CArgumentMan<_Str, _Chr>::ToAnsiArgs()
	{
		int nFromSize = sizeof(_Str().c_str()[0]);
		int nToSize = sizeof(std::string().c_str()[0]);
		assert(nFromSize > nToSize);

		std::map< std::string, std::vector<std::string> > ret;
		for (std::map< _Str, std::vector<_Str> >::iterator it = m_mapArgument.begin();
			it != m_mapArgument.end(); ++it)
		{
			std::string key; std::vector<std::string> args;
			WideByte2Ansi(key, it->first.c_str());

			std::vector<_Str>& _args = it->second;
			size_t nArgs = _args.size();
			for (size_t i = 0; i < nArgs; ++i)
			{
				std::string arg;
				WideByte2Ansi(arg, _args[i].c_str());
				args.push_back(arg);
			}

			ret.insert(std::make_pair(key, args));
		}

		return ret;
	}

	TEMPLATE
		std::map<std::wstring, std::vector<std::wstring>> AM::CArgumentMan<_Str, _Chr>::ToUnicodeArgs()
	{
		int nFromSize = sizeof(_Str().c_str()[0]);
		int nToSize = sizeof(std::wstring().c_str()[0]);
		assert(nFromSize < nToSize);

		std::map< std::wstring, std::vector<std::wstring> > ret;
		for (std::map< _Str, std::vector<_Str> >::iterator it = m_mapArgument.begin();
			it != m_mapArgument.end(); ++it)
		{
			std::wstring key; std::vector<std::wstring> args;
			Ansi2WideByte(key, it->first.c_str());

			std::vector<_Str>& _args = it->second;
			size_t nArgs = _args.size();
			for (size_t i = 0; i < nArgs; ++i)
			{
				std::wstring arg;
				Ansi2WideByte(arg, _args[i].c_str());
				args.push_back(arg);
			}

			ret.insert(std::make_pair(key, args));
		}

		return ret;
	}

	TEMPLATE
		std::vector<std::string> AM::CArgumentMan<_Str, _Chr>::GetAnsiArgs(const std::string &sArgName)
	{
		std::string name = sArgName;
		makeName<std::string>(name);

		std::map< std::string, std::vector<std::string> > argsMap = ToAnsiArgs();
		if (argsMap.find(name) != argsMap.end())
			return argsMap[name];
		return std::vector<std::string>();
	}

	TEMPLATE
		std::vector<std::wstring> AM::CArgumentMan<_Str, _Chr>::GetUnicodeArgs(const std::wstring &sArgName)
	{
		std::wstring name = sArgName;
		makeName<std::wstring>(name);

		std::map< std::wstring, std::vector<std::wstring> > argsMap = ToUnicodeArgs();
		if (argsMap.find(name) != argsMap.end())
			return argsMap[name];
		return std::vector<std::wstring>();
	}

	TEMPLATE
		std::string AM::CArgumentMan<_Str, _Chr>::GetAnsiArg(const std::string &sArgName)
	{
		std::string name = sArgName;
		makeName<std::string>(name);

		std::map< std::string, std::vector<std::string> > argsMap = ToAnsiArgs();
		if (argsMap.find(name) != argsMap.end())
		{
			std::vector<std::string>& args = argsMap[name];
			if (args.size() > 0)
				return args[0];
		}
		return std::string();
	}

	TEMPLATE
		std::wstring AM::CArgumentMan<_Str, _Chr>::GetUnicodeArg(const std::wstring &sArgName)
	{
		std::wstring name = sArgName;
		makeName<std::wstring>(name);

		std::map< std::wstring, std::vector<std::wstring> > argsMap = ToUnicodeArgs();
		if (argsMap.find(name) != argsMap.end())
		{
			std::vector<std::wstring>& args = argsMap[name];
			if (args.size() > 0)
				return args[0];
		}
		return std::wstring();
	}

	TEMPLATE
		bool AM::CArgumentMan<_Str, _Chr>::HasAnsi(std::string &sOutArg, const std::string &sArgName)
	{
		std::string name = sArgName;
		makeName<std::string>(name);

		std::map< std::string, std::vector<std::string> > argsMap = ToAnsiArgs();
		if (argsMap.find(name) == argsMap.end())
		{
			return false;
		}

		std::vector<std::string>& _args = argsMap[name];
		if (_args.size() > 0)
			sOutArg = _args[0];

		return true;
	}

	TEMPLATE
		bool AM::CArgumentMan<_Str, _Chr>::HasAnsi(std::vector<std::string> &vctOutArgs, const std::string &sArgName)
	{
		std::string name = sArgName;
		makeName<std::string>(name);

		std::map< std::string, std::vector<std::string> > argsMap = ToAnsiArgs();
		if (argsMap.find(name) == argsMap.end())
		{
			return false;
		}

		std::vector<std::string>& _args = argsMap[name];
		size_t nSize = _args.size();
		for (size_t i = 0; i < nSize; ++i)
		{
			vctOutArgs.push_back(_args[i]);
		}

		return true;
	}

	TEMPLATE
		bool AM::CArgumentMan<_Str, _Chr>::HasUnicode(std::wstring &sOutArg, const std::wstring &sArgName)
	{
		std::wstring name = sArgName;
		makeName<std::wstring>(name);

		std::map< std::wstring, std::vector<std::wstring> > argsMap = ToUnicodeArgs();
		if (argsMap.find(name) == argsMap.end())
		{
			return false;
		}

		std::vector<std::wstring>& _args = argsMap[name];
		if (_args.size() > 0)
			sOutArg = _args[0];

		return true;
	}

	TEMPLATE
		bool AM::CArgumentMan<_Str, _Chr>::HasUnicode(std::vector<std::wstring> &vctOutArgs, const std::wstring &sArgName)
	{
		std::wstring name = sArgName;
		makeName<std::wstring>(name);

		std::map< std::wstring, std::vector<std::wstring> > argsMap = ToUnicodeArgs();
		if (argsMap.find(name) == argsMap.end())
		{
			return false;
		}

		std::vector<std::wstring>& _args = argsMap[name];
		size_t nSize = _args.size();
		for (size_t i = 0; i < nSize; ++i)
		{
			vctOutArgs.push_back(_args[i]);
		}

		return true;
	}

}

#ifdef _MSC_VER
#pragma  warning(  pop  ) 
#endif

应用实例：

#include "ArgumentMan.h"

void main(int argc, char** argv)
{
	{
		AM::CArgumentMan<std::string, char> am;
		am.AddCmdFlag('/');
		am.AddCmdFlag('-');
		am.AddCmdFlag('\\');
		am.SetIgnoreCase(true);
		am.SetMultiValue(true);
		am.Parse(argc, argv);

		std::map<std::string, std::vector<std::string>> orgArgs = am.GetArgs();
		std::vector<std::string> args = am.GetArgs("name");
		std::string arg = am.GetArg("name");

		std::vector<std::string> hargs;
		am.Has(hargs, "name");

		std::string harg;
		am.Has(harg, "name");

		std::map<std::wstring, std::vector<std::wstring>> wargs = am.ToUnicodeArgs();

		std::vector<std::wstring> hwargs;
		am.HasUnicode(hwargs, L"姓名");
		std::wstring hwarg;
		am.HasUnicode(hwarg, L"姓名");
	}
	{
		wchar_t **pp = new wchar_t *[argc];
		for (int i = 0; i<argc; ++i)
		{
			pp[i] = new wchar_t[256];
			memset(pp[i], '\0', 256);
			std::wstring out;
			AM::Ansi2WideByte(out, argv[i]);
			wcscpy(pp[i], out.c_str());
		}
		AM::CArgumentMan<std::wstring, wchar_t> am;
		am.AddCmdFlag('/');
		am.AddCmdFlag('-');
		am.AddCmdFlag('\\');
		am.SetIgnoreCase(true);
		am.SetMultiValue(true);
		am.Parse(argc, pp);

		std::map<std::wstring, std::vector<std::wstring>> orgArgs = am.GetArgs();
		std::vector<std::wstring> args = am.GetArgs(L"name");
		std::wstring arg = am.GetArg(L"name");

		std::vector<std::wstring> hargs;
		am.Has(hargs, L"name");

		std::wstring harg;
		am.Has(harg, L"name");

		std::map<std::string, std::vector<std::string>> aargs = am.ToAnsiArgs();

		std::vector<std::string> haargs;
		am.HasAnsi(haargs, "姓名");
		std::string haarg;
		am.HasAnsi(haarg, "姓名");
	}
}


gergul
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自写的一个C/C++程序的参数管理类
02-12
源码：wsdConfigMgr.hwsdConfigMgr.cpp另附配置文件例子：config.ini感觉C/C++管理配置文件与参数不如Java那样自在，于是自己写了这么一个东西。如有高人，请不吝赐教！
C++课程管理
02-13
在本项目"**C++课程管理**"中，我们将利用C++编程语言设计并实现一个课程管理系统。这个系统旨在帮助教育机构或个人更好地管理和组织课程信息。通过参与这个项目，开发者不仅能深化对C++语言的理解，还能掌握在Linux...
10.ROS编程学习：参数管理机制c++实现
wzfafabga的博客
10-20 1555
10.ROS编程学习：参数管理机制c++实现
系统参数配置的存储管理与应用的通用方法(C++实现)
weixin_33681778的博客
12-07 249
转载于:https://blog.51cto.com/cxxsoft/1081186
C++可变参数接口,批量写入和读取参数值的设计和实现
最新发布
红军不怕远征难，万水千山只等闲
04-29 805
最近在做项目的时候，我们小组做的模块和另外一个小组做的模块的交付通过动态库接口的方式，他们有一个接口是这样的定义的： name是参数名称，data为序列化的字节数据，小端对齐，数据类型包括一般数据类型int、long、double等；复杂数据类型包括原生数组、结构体、类等。例如：单个参数的配置和读取都很简单，利用之前章节介绍的序列化类，参数配置可以这样写：参数1(int)的配置代码如下： 参数2(bool)的配置代码如下： 参数3(double)的配置代码如下： 参数4(int[10])的配
C++实现的命令行参数管理
欣宇的专栏
11-20 5711
在编写可运行程序时，经常需要输入除了可运行文件之外的其它的命令行参数，可以用传统的getopt函数来分析，本文基于面向对象，分析一种管理命令行参数方法 -- 来源于webrtc项目，在阅读过程中，大家分享一下。 一，传统命令行分析 包含头文件：#include 　　int getopt(int argc,char * const argv[ ],const char * optst
例程四、c读写文件与文件参数管理
dingdongkk~博客
08-23 521
直接上代码，代码简单易懂。#include<stdio.h> #define PARAM_CONFIG "/home/lkg/test/config" typedef struct{ unsigned short int id; int offset; }param_offset; typedef struct { char c; int h; unsigne
C/C++语言之函数参数栈管理
Net_Wolf_007的专栏
10-27 1261
   我们知道C语言的基本组成单元是函数，各个函数之间可以相互引用。而函数的参数值，局部变量都是放到栈中管理。所以了解栈的管理工作是非常必要的。而对栈的管理工作中，我们最关心的就是函数参数及局部变量的入栈顺序。      我们调用一个函数，执行过程发生跳转，必然要把必要的寄存器入栈。然后把参数入栈，接着把局部变量入栈。执行完程序之后再把这些反序出栈。注：如果熟悉汇编的话写个函数看它的汇编代
c++引用/参数/动态空间管理
starmultiple的博客
03-24 232
2-7引用的声明及访问示例 #include<iostream> using namespace std; int x = 5, y = 10; int &r = x;//声明一个引用r作为变量x的别名 void print() { cout << "x=" << x << "y=" << y << "r=" << r << endl; cout << "Address of x" &lt
C++中类使用全局变量
07-07
在C++中，声明一个类，并且定义一个全局变量，练习全局变量的使用。注意全局变量的使用技巧和方法。
c++实现通用参数解析类示例
09-04
总结来说，这个示例提供了C++中处理命令行参数的一种解决方案，通过创建一个参数解析类，可以更方便地管理和验证用户输入的参数。这在开发命令行工具或者需要接收复杂配置的程序时非常有用。这样的设计允许程序...
C++员工管理系统
05-31
"C++员工管理系统知识点" 标题解释 这个C++员工管理系统是一个基于C++语言的员工管理系统，旨在帮助企业管理人员的信息，包括基本信息、工资计算、奖金计算等功能。 描述解释 这个系统是自己设计的，比较简单，但...
C++实现员工工资管理系统
07-05
《C++实现员工工资管理系统详解》 在信息技术领域，开发一个员工工资管理系统是常见的实践项目，它能够帮助企业高效地管理员工薪资数据。本系统采用C++编程语言，结合MVC（Model-View-Controller）设计模式，实现了...
C++开发的个人收支管理系统
04-26
标题：“C++开发的个人收支管理系统” 在IT领域，个人收支管理系统是一种常见的软件应用，用于帮助用户记录和管理他们的日常财务状况。在这个项目中，我们关注的是使用C++编程语言实现的一个版本。C++是一种强大的...
C/C++ 控制台程序参数
weixin_33728708的博客
04-15 467
源代码// 包含 头文件#include <stdio.h>// 程序入口函数，包含两个参数// 参数://argc --- 整型，运行程序时所带的参数个数//argv --- char* 型数组，具体的参数// 返回值: //0----- 整型(此例中 固定为 0) int main(int argc, c...
C语言参数管理代码框架
大橙子的博客
02-27 1649
介绍一个参数管理框架代码
C++可变参数函数模板和可变参数类模板
qq_52399817的博客
04-19 825
C++可变参数函数模板和可变参数类模板
C语言内存管理和参数传递浅析
空山新雨后
09-16 308
看了一些大佬对C语言细节的分析，觉得自己的C真是白学了，从新开始记录C语言的学习。 首先看一个例子：（内存管理）char *getmemery() { char p[] = "hello world!"; return p; } main() { char *str = NULL; str = getmemery(); pr
全局数据管理—使用C++类的静态成员取代全局数据
Dreamcode ~ CWMP TR069 ACS
10-10 1522
有时在工程中，所有类的对象需要共用一个变量（或者说共用一块存储空间），在c语言中可以使用全局变量，但这是一个非常不安全的做法。  您可以通过以下链接下载本文：http://download.csdn.net/source/260989
c++学生成绩管理系统文档.doc
11-15
c++学生成绩管理系统文档.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值