<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[PENGH56的专栏]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/PENGH56</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; PENGH56]]></copyright><item><title><![CDATA[Effective mordern c++ --- 类型推导]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/78784417</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/78784417</guid><author>PENGH56</author><pubDate>Tue, 12 Dec 2017 18:15:10 +0800</pubDate><description><![CDATA[扎实的理解模板、auto、decltype三种类型推导十分必要。
1.理解模板参数类型推导
首先定义模板参数类型推导的定义

template
void f(ParamType param)
当我们调用f(expr)时，我们可以从expr同时推导出T和ParamType两种类型，这里的ParamType跟T可以不同，比如 ParamType = const T&.这里需要分三种情况：]]></description><category></category></item><item><title><![CDATA[C++11多线程学习---线程函数的参数传递]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/78244509</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/78244509</guid><author>PENGH56</author><pubDate>Sun, 15 Oct 2017 21:43:04 +0800</pubDate><description><![CDATA[线程参数传递要记住一个重要的事情，传递的参数是存在新线程一个内部的转存站中，之后在函数执行的时候再传递给函数本身的。
这种机制会引发两个问题：
1.临时参数的未及时构造
void f(int i,std::string const& s);

void oops(int some_param)
{
    char buffer[1024];
    sprintf(buffer,"%i",]]></description><category></category></item><item><title><![CDATA[electron安装设置代理的坑]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/73551360</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/73551360</guid><author>PENGH56</author><pubDate>Wed, 21 Jun 2017 17:49:45 +0800</pubDate><description><![CDATA[最近尝试安装electron，安装了很久一直报错：



尝试了很多方法，最后发现是.nmprc的配置有问题，以下是我电脑可正常安装的.npmrc的配置：

registry=https://registry.npm.taobao.org
sass_binary_site=https://npm.taobao.org/mirrors/node-sass/
phantomjs_cdnurl=http...]]></description><category></category></item><item><title><![CDATA[STL源码解析---深入理解vector]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/53706809</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/53706809</guid><author>PENGH56</author><pubDate>Sat, 17 Dec 2016 14:51:52 +0800</pubDate><description><![CDATA[1.vector的特性
vector的数据安排以及操作方式与array非常类似，两者的唯一差别在于空间运用的灵活性。
vetor是动态空间，随着元素的加入，他的内部机制会自行扩充空间以容纳新元素。


2.vector的迭代器
因为vector维护的是一个连续的线性空间，所以不论其元素型别为何，普通指针都可以作为vector的迭代器而满足所有必要条件。
如operator*,oper]]></description><category></category></item><item><title><![CDATA[COM思想学习---把接口从实现中分离出来]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/53444122</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/53444122</guid><author>PENGH56</author><pubDate>Sat, 03 Dec 2016 14:53:28 +0800</pubDate><description><![CDATA[1.在封装DLL时，首先介绍一下句柄类的思想：
当一个类里面有具体的实现内容并且有迭代更新的可能，我们通常不会把这个类选择导出。一种常用的思想是借鉴句柄的实现方式：
class FastStringItf
{
    class FastString;
    FastString * m_pThis;
public:
    FastStringItf(const char * psz);
]]></description><category></category></item><item><title><![CDATA[C++多线程学习---线程间的共享数据]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/53256613</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/53256613</guid><author>PENGH56</author><pubDate>Mon, 21 Nov 2016 15:02:21 +0800</pubDate><description><![CDATA[多线程间的共享数据如果不加以约束是有问题的。最简单的方法就是对数据结构采用某种保护机制，通俗的表达就是：
确保只有进行修改的线程才能看到不变量被破坏时的中间状态。从其他访问线程的角度来看，修改不是已经完成了，就是还没开始。

1.使用互斥量保护共享数据
    当访问共享数据前，使用互斥量将相关数据锁住，再当访问结束后，再将数据解锁。C++标准库为互斥量提供了一个RAII语法的模板类std]]></description><category></category></item><item><title><![CDATA[C++多线程学习---线程管理基础]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/53231633</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/53231633</guid><author>PENGH56</author><pubDate>Sat, 19 Nov 2016 16:29:16 +0800</pubDate><description><![CDATA[1.堤防函数已经结束，线程依然访问局部变量看以下例子： 
struct func 
{ 
    int& i; 
    func(int& i_) : i(i_) {} 
    void operator() () 
    { 
        for (unsigned j=0 ; j<1000000 ; ++j) 
        { 
        do_something(i);]]></description><category></category></item><item><title><![CDATA[C++ 多线程学习---多线程的世界]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/53228155</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/53228155</guid><author>PENGH56</author><pubDate>Sat, 19 Nov 2016 11:20:55 +0800</pubDate><description><![CDATA[1.在程序中，并发的实现方式有两种：
a.多进程并发
    将每个单独的行为放置到进程中，缺点是进程之间的通信通设置复杂，速度慢，因为操作系统会在进程间提供了一定的保护措施，避免一个进程去修改另一个进程的数据。还有一个缺点是，运行多个进程所需的固定开销：需要时间启动进程，操作系统需要内部资源来管理进程，等等。
优点是：操作系统在进程间提供附加的保护操作和更高级别的通信机制，意味着可以更容易]]></description><category></category></item><item><title><![CDATA[More Effective C++ -----将构造函数和非成员函数虚拟化]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/53120546</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/53120546</guid><author>PENGH56</author><pubDate>Thu, 10 Nov 2016 20:26:31 +0800</pubDate><description><![CDATA[本篇有三个重点：
1.虚拟构造函数
由于类自身的构造函数是无法定义成虚函数的，但是往往会有根据不同输入产生不同对象的需求，于是出现了以下函数：
clss NLComponent;
class TextBlock: public NLComponent
{
}
class Graphic:public NLComponent
{
}
class NewsLetter
{
public:
pri]]></description><category></category></item><item><title><![CDATA[More Effective C++ --- 理解临时对象]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/53104117</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/53104117</guid><author>PENGH56</author><pubDate>Wed, 09 Nov 2016 20:10:02 +0800</pubDate><description><![CDATA[首先理解临时对象的概念
template
void Swap(T& object1,T& object2)
{    T temp = object1;    object1 = object2;    object2 = temp;
}上述中的temp只是函数的一个局部对象，而真正的临时对象时看不见的!
临时对象通常在两种条件下产生。
1.为了使函数调用成功进行隐式转换
2.函数返回对象]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---将文件间的编译依存关系降至最低]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52901535</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52901535</guid><author>PENGH56</author><pubDate>Sun, 23 Oct 2016 14:24:15 +0800</pubDate><description><![CDATA[如果你对C++程序的某个类做了轻微的修改，修改的不是接口而是实现，当编译时，很多关联的文件都需要重新编译。
以以下程序为例：
class Person
{
public:
	...
private:
	std::string theName;        //实现细目
	Date theBirthDate;          //实现细目
	Address theAddress;		//实现]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---透彻了解Inline函数]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52901373</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52901373</guid><author>PENGH56</author><pubDate>Sun, 23 Oct 2016 13:59:46 +0800</pubDate><description><![CDATA[inline 函数可以免除函数调用成本，使程序更加高效。但过度的inline又会导致代码膨胀，内存增加。
仔细介绍一下inline函数
1.inline只是编译器的一个申请，不是强制的命令。
大部分编译器会拒绝太复杂的函数inline,而对所有virtual函数的也无法inline.
因为virtual函数要等到运行期才决定调用哪个函数。
总结就是一个函数是否是inline的最终决定权不]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---将成员变量声明为Private；宁以非成员、非友元函数替换成员函数]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52901264</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52901264</guid><author>PENGH56</author><pubDate>Sun, 23 Oct 2016 13:37:03 +0800</pubDate><description><![CDATA[将成员变量声明为Private

原因如下：
1，语法一致性，暴露出来的都是函数
2.可以对每一个变量实现权限控制，“不准访问”“只读访问”“读写访问”
3.具备更好的封装性，可以有效保障在更改某些成员变量时不会影响客户的使用
protected成员变量同样不具备较好的封装性。


宁以非成员、非友元函数替换成员函数

此条款的逻辑是这样的，当我们讨论一个类的封装性的时候。越]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---尽可能延后变量定义式出现的时间]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52203427</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52203427</guid><author>PENGH56</author><pubDate>Sun, 14 Aug 2016 10:46:47 +0800</pubDate><description><![CDATA[如果定义了一个带有构造函数和析构函数的变量，那么程序就要承受构造和析构的成本----你必须考虑这件事情
考虑以下函数：
std::string encryptPassword(const std::string& password)
{
    using namespace std;
    string encrypted;
    if(password.length() < MiniL]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---宁以传递const引用替换值传递]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52176687</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52176687</guid><author>PENGH56</author><pubDate>Wed, 10 Aug 2016 21:53:52 +0800</pubDate><description><![CDATA[你必须知道，函数参数以值传递的效率太低：
class Person
{
  public:
    Person();
    virtual ~Person();
  private:
   std::string name;
   std::string address;

}
class Student:public Person
{
  public:
   Student();
  ~]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---设计与声明]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52176546</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52176546</guid><author>PENGH56</author><pubDate>Wed, 10 Aug 2016 21:37:27 +0800</pubDate><description><![CDATA[良好的设计与声明习惯可以有效提高C++代码质量。

在设计接口时请记住一个原则：.让接口容易被正确使用，不易被误。
以下方法可供参考：

a.增加新的类型预防用户调用接口出错
假设如下例子：
class Date
{
  public:
    Date(int month,int day,int year);
}
用户有可能将年、月、日的顺序搞反
struct Day{};
s]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---资源管理要点总结]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52166602</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52166602</guid><author>PENGH56</author><pubDate>Tue, 09 Aug 2016 22:00:19 +0800</pubDate><description><![CDATA[什么是资源？
资源就是一旦使用，将来必须交还给系统，否则会发生各种异常情况。典型的资源就是动态内存分配。
其他常见资源包括互斥锁、数据库连接、画刷、网络sockets等。
有效管理资源的方式：
一 .以对象管理资源,确保两点：
a.获得资源后立刻放进管理对象内。
b.管理对象运用析构函数确保资源被释放。
典型的以对象管理资源的例子为：
1.autoPtr
AutoPtr 在拷贝赋]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---复制对象时勿忘每一个成员]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52166563</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52166563</guid><author>PENGH56</author><pubDate>Tue, 09 Aug 2016 21:52:33 +0800</pubDate><description><![CDATA[核心点有两个：
1、如果你坚持自己重写拷贝构造函数，请记住：编译器是不会提醒你是否少复制了某一个成员。
2、如果你重写派生类的拷贝构造函数和拷贝操作符时，请记住：他们不会自动调用积累的拷贝构造函数和拷贝操作符。
以下为例子，注意手动调用基类的构造函数：
class PriorityCustomer:Public Customer
{
   public:
     PriorityCust]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---合理处理Operator =]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52130754</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52130754</guid><author>PENGH56</author><pubDate>Fri, 05 Aug 2016 16:59:44 +0800</pubDate><description><![CDATA[如果你重新Operator = 时，注意以下两个事情：
1.令operator= 返回一个指向对象自身的引用
为了方便连锁赋值，如
 int x,y,z;
  x= y =z;
为了自定义对象也实现同样的效果，必须将赋值操作符返回一个指向自身的引用：
class Widget
{
  public:
     Widget& operator = (const Widget& rhs)]]></description><category></category></item><item><title><![CDATA[Effective C++读书笔记---为多态基类声明为virtual析构函数]]></title><link>https://blog.youkuaiyun.com/PENGH56/article/details/52130643</link><guid>https://blog.youkuaiyun.com/PENGH56/article/details/52130643</guid><author>PENGH56</author><pubDate>Fri, 05 Aug 2016 16:48:01 +0800</pubDate><description><![CDATA[本篇文章有三个重点
1.为多态基类声明为virtual析构函数
原因很简单，在释放基类指针时会先调用继承类的析构函数。
只有当class内含至少一个virtual函数时，才能将其声明为virtual析构函数。无故声明virtual会增加内存开销。
对于纯虚析构函数，在声明为纯虚析构函数后还需要为其提供一份定义，因为析构函数的运作方式是最深层派生的class其析构函数最先被调用，然后是每一个]]></description><category></category></item></channel></rss>