精华内容
下载资源
问答
  • C++程序员经常11个问题 这篇文章收了好长时间,但还是觉得贴出来,作为收藏,在网上这样浮躁环境,很少能认认真真地这样长文章,有时间我也要把《Effective C++》读书笔记作出来。 以下是原文: ...

    C++程序员经常问的11个问题

    这篇文章收了好长时间,但还是觉得贴出来,作为收藏,在网上这样的浮躁环境,很少能认认真真地看这样长的文章,有时间我也要把《Effective C++》的读书笔记作出来。

    以下是原文:

           下面的这些要点是对所有的C++程序员都适用的。我之所以说它们是最重要的,是因为这些要点中提到的是你通常在C++书中或网站上无法找到的。如:指向成员的指针,这是许多资料中都不愿提到的地方,也是经常出错的地方,甚至是对一些高级的C++程序员也是如此。
      这里的要点不仅仅是解释怎样写出更好的代码,更多的是展现出语言规则里面的东西。很显然,它们对C++程序员来说是永久的好资料。我相信这一篇文章会使你收获不小。

      首先,我把一些由不同层次的C++程序员经常问的问题归到一起。我惊奇的发现有很多是有经验的程序员都还没意识到 .h 符号是否还应该出现在标准头文件中。

     

    要点1: 还是 ?

       很多C++程序员还在使用而不是用更新的标准的库。这两者都有什么不同呢?首 先,5年前我们就开始反对把.h符号继续用在标准的头文件中。继续使用过时的规则可不是个好的方法。从功能性的角度来讲,< iostream>包含了一系列模板化的I/O类,相反地只仅仅是支持字符流。另外,输入输出流的C++标准 规范接口在一些微妙的细节上都已改进,因此,和在接口和执行上都是不同的。最后, 的各组成都是以STL的形式声明的,然而的各组成都是声明成全局型的。

      因为这些实质上的不同,你不能在一个程序中混淆使用这两个库。做为一种习惯,在新的代码中一般使用,但如果你处理的是过去编写的代码,为了继承可以用继续用旧保持代码的一致性。  


    要点2:用引用传递参数时应注意的地方

      在用引用传递参数时,最好把引用声明为const类型。这样做的好处是:告诉程序不能修改这个参数。在下面的这个例子中函数f()就是传递的引用:
    void f(const int & i);
    int main()
    {
     f(2); /* OK */
    }
       这个程序传递一个参数2给f()。在运行时,C++创建一个值为2的int类型的临时变量,并传递它的引用给f().这个临时变量和它的引用从f()被 调用开始被创建并存在直到函数返回。返回时,就被马上删除。注意,如果我们不在引用前加上const限定词,则函数f()可能会更改它参数的值,更可能会 使程序产生意想不到的行为。所以,别忘了const。

      这个要点也适用于用户定义的对象。你可以给临时对象也加上引用如果是const类型:
    struct A{};
    void f(const A& a);
    int main()
    {
     f(A()); // OK,传递的是一个临时A的const引用
    }

     

    要点3:“逗号分离”表达形式

     “逗号分离”表达形式是从C继承来的,使用在for-和while-循环中。当然,这条语法规则被认为是不直观的。首先,我们来看看什么是“逗号分离”表达形式。

      一个表达式由一个或多个其它表达式构成,由逗号分开,如:
     if(++x, --y, cin.good()) //三个表达式
      这个if条件包含了三个由逗号分离的表达式。C++会计算每个表达式,但完整的“逗号分离”表达式的结果是最右边表达式的值。因此,仅当cin.good()返回true时,if条件的值才是true。下面是另一个例子:
    int j=10;
    int i=0;
    while( ++i, --j)
    {
     //直到j=0时,循环结束,在循环时,i不断自加
    }

     

    要点4,使用全局对象的构造函数在程序启动前调用函数

       有一些应用程序需要在主程序启动前调用其它函数。如:转态过程函数、登记功能函数都是必须在实际程序运行前被调用的。最简单的办法是通过一个全局对象的 构造函数来调用这些函数。因为全局对象都是在主程序开始前被构造,这些函数都将会在main()之前返回结果。如:
    class Logger
    {
     public:
     Logger()
      {
       activate_log();//译者注:在构造函数中调用你需要先运行的函数
      }
    };
    Logger log; //一个全局实例
    int main()
    {
     record * prec=read_log();//译者注:读取log文件数据
     //.. 程序代码
    }
      全局对象log在main()运行之前被构造,log调用了函数activate_log()。从而,当main()开始执行时,它就可以从log文件中读取数据。

      毫无疑问地,在C++编程中内存管理是最复杂和最容易出现bug的地方。直接访问原始内存、动态分配存储和最大限度的发挥C++指令效率,都使你必须尽力避免有关内存的bug。
      
    要点5:避免使用复杂构造的指向函数的指针

      指向函数的指针是C++中可读性最差的语法之一。你能告诉我下面语句的意思吗?
    void (*p[10]) (void (*)());
       P是一个“由10个指针构成的指向一个返回void类型且指向另一个无返回和无运算的函数的数组”。这个麻烦的语法真是让人难以辨认,不是吗?你其实可 以简单的通过typedef来声明相当于上面语句的函数。首先,使用typedef声明“指向一个无返回和无运算的函数的指针”:
    typedef void (*pfv)();
      接着,声明“另一个指向无返回且使用pfv的函数指针”:
    typedef void (*pf_taking_pfv) (pfv);
      现在,声明一个由10个上面这样的指针构成的数组:
    pf_taking_pfv p[10];
      与void (*p[10]) (void (*)())达到同样效果。但这样是不是更具有可读性了!

     

    要点6:指向成员的指针

      一个类有两种基本的成员:函数成员和数据成员。同样的,指向成员的指针也有两种:指向函数成员的指针和指向数据成员的指针。后则其实并不常用,因为类一般是不含有公共数据成员的,仅当用在继承用C写的代码时协调结构(struct)和类(class)时才会用到。

       指向成员的指针是C++语法中最难以理解的构造之一,但是这也是一个C++最强大的特性。它可以让你调用一个类的函数成员而不必知道这个函数的名字。这 一个非常敏捷的调用工具。同样的,你也可以通过使用指向数据成员的指针来检查并改变这个数据而不必知道它的成员名字。
      指向数据成员的指针

      尽管刚开始时,指向成员的指针的语法会使你有一点点的迷惑,但你不久会发现它其实同普通的指针差不多,只不过是*号的前面多了::符号和类的名字,例:定义一个指向int型的指针:
    int * pi;
      定义一个指向为int型的类的数据成员:
    int A::*pmi; //pmi是指向类A的一个int型的成员
      你可以这样初始化它:
    class A
    {
     public:
     int num;
     int x;
    };
    int A::*pmi = & A::num;
      上面的代码是声明一个指向类A的一个int型的num成员并将它初始化为这个num成员的地址.通过在pmi前面加上*你就可以使用和更改类A的num成员的值:
    A a1, a2;
    int n=a1.*pmi; //把a1.num赋值给n
    a1.*pmi=5; // 把5赋值给a1.num
    a2.*pmi=6; // 把6赋值给6a2.num
      如果你定义了一个指向类A的指针,那么上面的操作你必须用 ->*操作符代替:
    A * pa=new A;
    int n=pa->*pmi;
    pa->*pmi=5;

      指向函数成员的指针

      它由函数成员所返回的数据类型构成,类名后跟上::符号、指针名和函数的参数列表。举个例子:一个指向类A的函数成员(该函数返回int类型)的指针:
    class A
    {
     public:
     int func ();
    };
    int (A::*pmf) ();
      上面的定义也就是说pmf是一个指向类A的函数成员func()的指针.实际上,这个指针和一个普通的指向函数的指针没什么不同,只是它包含了类的名字和::符号。你可以在在任何使用*pmf的地方调用这个函数
    func():
    pmf=&A::func;
    A a;
    (a.*pmf)(); //调用a.func()
      如果你先定义了一个指向对象的指针,那么上面的操作要用->*代替:
    A *pa=&a;
    (pa->*pmf)(); //调用pa->func()
      指向函数成员的指针要考虑多态性。所以,当你通过指针调用一个虚函数成员时,这个调用将会被动态回收。另一个需要注意的地方,你不能取一个类的构造函数和析构函数的地址。

     

    要点7、避免产生内存碎片

       经常会有这样的情况:你的应用程序每运行一次时就因为程序自身缺陷而产生内存漏洞而泄漏内存,而你又在周期性地重复着你的程序,结果可想而知,它也会使 系统崩溃。但怎样做才能预防呢?首先,尽量少使用动态内存。在大多数情况下,你可能使用静态或自动存储或者是STL容器。第二,尽量分配大块的内存而不是 一次只分配少量内存。举个例子:一次分配一个数组实例所需的内存,而不是一次只分配一个数组元素的内存。

     

    要点8、是delete还是delete[]

      在程序员中有个荒诞的说法:使用delete来代替delete[]删除数组类型时是可以的!
      举个例子吧:
     int *p=new int[10];
     delete p; //错误,应该是:delete[] p
      上面的程序是完全错误的。事实上,在一个平台上使用delete代替delete[]的应用程序也许不会造成系统崩溃,但那纯粹是运气。你不能保证你的应用程序是不是会在另一个编译器上编译,在另一个平台上运行,所以还是请使用delete[]。

     

    要点9、优化成员的排列

      一个类的大小可以被下面的方式改变:
    struct A
    {
     bool a;
     int b;
     bool c;
    }; //sizeof (A) == 12
       在我的电脑上sizeof (A) 等于12。这个结果可能会让你吃惊,因为A的成员总数是6个字节:1+4+1个字节。那另6字节是哪儿来的?编译器在每个bool成员后面都插入了3个填 充字节以保证每个成员都是按4字节排列,以便分界。你可以减少A的大小,通过以下方式:
    struct B
    {
     bool a;
     bool c;
     int b;
    }; // sizeof (B) == 8
      这一次,编译器只在成员c后插入了2个字节。因为b占了4个字节,所以就很自然地把它当作一个字的形式排列,而a和c的大小1+1=2,再加上2个字节就刚好按两个字的形式排列B。

     

    要点10、为什么继承一个没有虚析构函数的类是危险的?

       一个没有虚析构函数的类意味着不能做为一个基类。如std::string, std::complex, 和 std::vector 都是这样的。为什么继承一个没有虚析构函数的类是危险的?当你公有继承创建一个从基类继承的相关类时,指向新类对象中的指针和引用实际上都指向了起源的对 象。因为析构函数不是虚函数,所以当你delete一个这样的类时,C++就不会调用析构函数链。举个例子说明:
    class A
    {
     public:
     ~A() // 不是虚函数
     {
     // ...
     }
    };
    class B: public A //错; A没有虚析构函数
    {
     public:
     ~B()
     {
     // ...
     }
    };
    int main()
    {
     A * p = new B; //看上去是对的
     delete p; //错,B的析构函没有被调用
    }

     

    要点11、以友元类声明嵌套的类

      当你以友元类声明一个嵌套的类时,把友元声明放在嵌套类声明的后面,而不前面。
    class A
    {
     private:
     int i;
     public:
     class B //嵌套类声明在前
     {
      public:
      B(A & a) { a.i=0;};
     };
     friend class B;//友元类声明
    };

      如果你把友元类声明放在声明嵌套类的前面,编译器将抛弃友元类后的其它声明。

    https://blog.csdn.net/ithomer/article/details/5019203

    展开全文
  • 这篇文章收了好长时间,但还是觉得贴出来,作为收藏,在网上这样浮躁环境,很少能认认真真地这样长文章,有...如:指向成员指针,这是许多资料中都不愿提到地方,也是经常出错地方,甚至是对一些高级...
    这篇文章收了好长时间,但还是觉得贴出来,作为收藏,在网上这样的浮躁环境,很少能认认真真地看这样长的文章,有时间我也要把《Effective C++》的读书笔记作出来。以下是原文:


    下面的这些要点是对所有的C++程序员都适用的。我之所以说它们是最重要的,是因为这些要点中提到的是你通常在C++书中或网站上无法找到的。如:指向成员的指针,这是许多资料中都不愿提到的地方,也是经常出错的地方,甚至是对一些高级的C++程序员也是如此。 
      这里的要点不仅仅是解释怎样写出更好的代码,更多的是展现出语言规则里面的东西。很显然,它们对C++程序员来说是永久的好资料。我相信这一篇文章会使你收获不小。 

      首先,我把一些由不同层次的C++程序员经常问的问题归到一起。我惊奇的发现有很多是有经验的程序员都还没意识到 .h 符号是否还应该出现在标准头文件中。



    要点1: 还是 ? 

      很多C++程序员还在使用而不是用更新的标准的库。这两者都有什么不同呢?首先,5年前我们就开始反对把.h符号继续用在标准的头文件中。继续使用过时的规则可不是个好的方法。从功能性的角度来讲,< iostream>包含了一系列模板化的I/O类,相反地只仅仅是支持字符流。另外,输入输出流的C++标准规范接口在一些微妙的细节上都已改进,因此,和在接口和执行上都是不同的。最后, 的各组成都是以STL的形式声明的,然而的各组成都是声明成全局型的。

      因为这些实质上的不同,你不能在一个程序中混淆使用这两个库。做为一种习惯,在新的代码中一般使用,但如果你处理的是过去编写的代码,为了继承可以用继续用旧保持代码的一致性。  


    要点2:用引用传递参数时应注意的地方 

      在用引用传递参数时,最好把引用声明为const类型。这样做的好处是:告诉程序不能修改这个参数。在下面的这个例子中函数f()就是传递的引用: 
    void f(const int & i); 
    int main() 

     f(2); /* OK */ 

      这个程序传递一个参数2给f()。在运行时,C++创建一个值为2的int类型的临时变量,并传递它的引用给f().这个临时变量和它的引用从f()被调用开始被创建并存在直到函数返回。返回时,就被马上删除。注意,如果我们不在引用前加上const限定词,则函数f()可能会更改它参数的值,更可能会使程序产生意想不到的行为。所以,别忘了const。 

      这个要点也适用于用户定义的对象。你可以给临时对象也加上引用如果是const类型: 
    struct A{}; 
    void f(const A& a); 
    int main() 

     f(A()); // OK,传递的是一个临时A的const引用 


    要点3:“逗号分离”表达形式 

     “逗号分离”表达形式是从C继承来的,使用在for-和while-循环中。当然,这条语法规则被认为是不直观的。首先,我们来看看什么是“逗号分离”表达形式。

      一个表达式由一个或多个其它表达式构成,由逗号分开,如: 
     if(++x, --y, cin.good()) //三个表达式 
      这个if条件包含了三个由逗号分离的表达式。C++会计算每个表达式,但完整的“逗号分离”表达式的结果是最右边表达式的值。因此,仅当cin.good()返回true时,if条件的值才是true。下面是另一个例子: 
    int j=10; 
    int i=0; 
    while( ++i, --j) 

     //直到j=0时,循环结束,在循环时,i不断自加 


    要点4,使用全局对象的构造函数在程序启动前调用函数 

      有一些应用程序需要在主程序启动前调用其它函数。如:转态过程函数、登记功能函数都是必须在实际程序运行前被调用的。最简单的办法是通过一个全局对象的构造函数来调用这些函数。因为全局对象都是在主程序开始前被构造,这些函数都将会在main()之前返回结果。如: 
    class Logger 

     public: 
     Logger() 
      { 
       activate_log();//译者注:在构造函数中调用你需要先运行的函数 
      } 
    }; 
    Logger log; //一个全局实例 
    int main() 

     record * prec=read_log();//译者注:读取log文件数据 
     //.. 程序代码 

      全局对象log在main()运行之前被构造,log调用了函数activate_log()。从而,当main()开始执行时,它就可以从log文件中读取数据。 

      毫无疑问地,在C++编程中内存管理是最复杂和最容易出现bug的地方。直接访问原始内存、动态分配存储和最大限度的发挥C++指令效率,都使你必须尽力避免有关内存的bug。 
       
    要点5:避免使用复杂构造的指向函数的指针 

      指向函数的指针是C++中可读性最差的语法之一。你能告诉我下面语句的意思吗? 
    void (*p[10]) (void (*)()); 
      P是一个“由10个指针构成的指向一个返回void类型且指向另一个无返回和无运算的函数的数组”。这个麻烦的语法真是让人难以辨认,不是吗?你其实可以简单的通过typedef来声明相当于上面语句的函数。首先,使用typedef声明“指向一个无返回和无运算的函数的指针”: 
    typedef void (*pfv)(); 
      接着,声明“另一个指向无返回且使用pfv的函数指针”: 
    typedef void (*pf_taking_pfv) (pfv); 
      现在,声明一个由10个上面这样的指针构成的数组: 
    pf_taking_pfv p[10]; 
      与void (*p[10]) (void (*)())达到同样效果。但这样是不是更具有可读性了! 

    要点6:指向成员的指针 

      一个类有两种基本的成员:函数成员和数据成员。同样的,指向成员的指针也有两种:指向函数成员的指针和指向数据成员的指针。后则其实并不常用,因为类一般是不含有公共数据成员的,仅当用在继承用C写的代码时协调结构(struct)和类(class)时才会用到。

      指向成员的指针是C++语法中最难以理解的构造之一,但是这也是一个C++最强大的特性。它可以让你调用一个类的函数成员而不必知道这个函数的名字。这一个非常敏捷的调用工具。同样的,你也可以通过使用指向数据成员的指针来检查并改变这个数据而不必知道它的成员名字。 
      指向数据成员的指针 

      尽管刚开始时,指向成员的指针的语法会使你有一点点的迷惑,但你不久会发现它其实同普通的指针差不多,只不过是*号的前面多了::符号和类的名字,例:定义一个指向int型的指针: 
    int * pi; 
      定义一个指向为int型的类的数据成员: 
    int A::*pmi; //pmi是指向类A的一个int型的成员 
      你可以这样初始化它: 
    class A 

     public: 
     int num; 
     int x; 
    }; 
    int A::*pmi = & A::num; 
      上面的代码是声明一个指向类A的一个int型的num成员并将它初始化为这个num成员的地址.通过在pmi前面加上*你就可以使用和更改类A的num成员的值: 
    A a1, a2; 
    int n=a1.*pmi; //把a1.num赋值给n 
    a1.*pmi=5; // 把5赋值给a1.num 
    a2.*pmi=6; // 把6赋值给6a2.num 
      如果你定义了一个指向类A的指针,那么上面的操作你必须用 ->*操作符代替: 
    A * pa=new A; 
    int n=pa->*pmi; 
    pa->*pmi=5; 

      指向函数成员的指针

      它由函数成员所返回的数据类型构成,类名后跟上::符号、指针名和函数的参数列表。举个例子:一个指向类A的函数成员(该函数返回int类型)的指针: 
    class A 

     public: 
     int func (); 
    }; 
    int (A::*pmf) (); 
      上面的定义也就是说pmf是一个指向类A的函数成员func()的指针.实际上,这个指针和一个普通的指向函数的指针没什么不同,只是它包含了类的名字和::符号。你可以在在任何使用*pmf的地方调用这个函数 
    func(): 
    pmf=&A::func; 
    A a; 
    (a.*pmf)(); //调用a.func() 
      如果你先定义了一个指向对象的指针,那么上面的操作要用->*代替: 
    A *pa=&a; 
    (pa->*pmf)(); //调用pa->func() 
      指向函数成员的指针要考虑多态性。所以,当你通过指针调用一个虚函数成员时,这个调用将会被动态回收。另一个需要注意的地方,你不能取一个类的构造函数和析构函数的地址。 

    要点7、避免产生内存碎片 

      经常会有这样的情况:你的应用程序每运行一次时就因为程序自身缺陷而产生内存漏洞而泄漏内存,而你又在周期性地重复着你的程序,结果可想而知,它也会使系统崩溃。但怎样做才能预防呢?首先,尽量少使用动态内存。在大多数情况下,你可能使用静态或自动存储或者是STL容器。第二,尽量分配大块的内存而不是一次只分配少量内存。举个例子:一次分配一个数组实例所需的内存,而不是一次只分配一个数组元素的内存。 

    要点8、是delete还是delete[] 

      在程序员中有个荒诞的说法:使用delete来代替delete[]删除数组类型时是可以的! 
      举个例子吧: 
     int *p=new int[10]; 
     delete p; //错误,应该是:delete[] p 
      上面的程序是完全错误的。事实上,在一个平台上使用delete代替delete[]的应用程序也许不会造成系统崩溃,但那纯粹是运气。你不能保证你的应用程序是不是会在另一个编译器上编译,在另一个平台上运行,所以还是请使用delete[]。 

    要点9、优化成员的排列 

      一个类的大小可以被下面的方式改变: 
    struct A 

     bool a; 
     int b; 
     bool c; 
    }; //sizeof (A) == 12 
      在我的电脑上sizeof (A) 等于12。这个结果可能会让你吃惊,因为A的成员总数是6个字节:1+4+1个字节。那另6字节是哪儿来的?编译器在每个bool成员后面都插入了3个填充字节以保证每个成员都是按4字节排列,以便分界。你可以减少A的大小,通过以下方式: 
    struct B 

     bool a; 
     bool c; 
     int b; 
    }; // sizeof (B) == 8 
      这一次,编译器只在成员c后插入了2个字节。因为b占了4个字节,所以就很自然地把它当作一个字的形式排列,而a和c的大小1+1=2,再加上2个字节就刚好按两个字的形式排列B。 

    要点10、为什么继承一个没有虚析构函数的类是危险的? 

      一个没有虚析构函数的类意味着不能做为一个基类。如std::string, std::complex, 和 std::vector 都是这样的。为什么继承一个没有虚析构函数的类是危险的?当你公有继承创建一个从基类继承的相关类时,指向新类对象中的指针和引用实际上都指向了起源的对象。因为析构函数不是虚函数,所以当你delete一个这样的类时,C++就不会调用析构函数链。举个例子说明: 
    class A 

     public: 
     ~A() // 不是虚函数 
     { 
     // ... 
     } 
    }; 
    class B: public A //错; A没有虚析构函数 

     public: 
     ~B() 
     { 
     // ... 
     } 
    }; 
    int main() 

     A * p = new B; //看上去是对的 
     delete p; //错,B的析构函没有被调用 


    要点11、以友元类声明嵌套的类 

      当你以友元类声明一个嵌套的类时,把友元声明放在嵌套类声明的后面,而不前面。 
    class A 

     private: 
     int i; 
     public: 
     class B //嵌套类声明在前 
     { 
      public: 
      B(A & a) { a.i=0;}; 
     }; 
     friend class B;//友元类声明 
    }; 
      如果你把友元类声明放在声明嵌套类的前面,编译器将抛弃友元类后的其它声明

    转载于:https://www.cnblogs.com/zhangyin/archive/2007/01/22/626427.html

    展开全文
  • 牛人程序员最爱逛10大编程网站,你知道几个?

    万次阅读 多人点赞 2018-06-30 02:38:34
    今天我给大家推荐10个高级程序员经常的网站,你又去过几个呢?来跟着小编一起看看都有哪些牛逼的网站吧。分享之前我还是要推荐下我自己的前端学习群:653415492,不管你是小白还是大牛,小编我都挺欢迎,不定期...

    今天我给大家推荐10个高级程序员经常逛的网站,你又去过几个呢?来跟着小编一起看看都有哪些牛逼的网站吧。

    分享之前我还是要推荐下我自己的前端学习群:653415492,不管你是小白还是大牛,小编我都挺欢迎,不定期分享干货,,欢迎初学和进阶中的小伙伴

    0.https://github.com/trending


    1.http://stackoverflow.com/


    2.https://segmentfault.com/


    3.https://blog.csdn.net/mcuhome


    4.http://blog.51cto.com/13845070


    5.https://www.oschina.net/project/list?sort=time


    6.https://itso123.com/

    这个导航网站是我良心提供,只要你还是个程序员,你就一定用的着,无论你是前端还是做硬件!


    最后再来给程序员提几点建议:

    学习最忌三心二意。俗话说:“伤其十指不如断其一指”,每门都学一点,还不如专心学好一个方向。这个道理谁都懂,可是又该学哪个方向呢?难道只能跟着感觉走吗?不!最实际的方向,应该跟着工作走,工作需要什么,我们就学什么,把工作需要的技能熟练掌握,有很多好处。

    首先,可以集中精力,在某一方面钻研得更加深入。所谓“百招会不如一招绝”,有了绝招,你还怕不能在“武林”立足吗?《天龙八部》中的慕容复武功博学无比,最后还不是被只会一招六脉神剑的段誉打得落花流水?

    其次,可以学得更快、更深入,因为学习更具有针对性,而且可以立即在工作中运用,可以马上检验出学习的效果。对存在的问题进行深入研究,掌握的知识也会更加牢固。


    最后请加入我们,无论前端还是后端,我们网罗了一大波技术大牛来和大家分享最新的技术!



    展开全文
  • 今天我给大家推荐10个高级程序员经常的网站,你又去过几个呢?来跟着小编一起看看都有哪些牛逼的网站吧。 0.https://github.com/trending 全球最大的开源仓库网站,不过现在嫁给微软了。 ) 1....

    今天我给大家推荐10个高级程序员经常逛的网站,你又去过几个呢?来跟着小编一起看看都有哪些牛逼的网站吧。

    0.https://github.com/trending

    全球最大的开源仓库网站,不过现在嫁给微软了。

    )

    1.http://stackoverflow.com/

    踩过坑的都不会不知道她,解救程序员于危难之间啊

    2.https://segmentfault.com/

    感觉和楼上是两个×××妹啊

    3.https://blog.csdn.net/mcuhome

    中国x大程序员交友网站

    4.https://blog.51cto.com/13845070

    中国x大程序员交友网站

    5.https://www.oschina.net/project/list?sort=time

    国内最大的开源网站

    6.http://www.chenzhuofan.top/

    这个不用介绍了,程序员导航,大家都在用的。

     

     

    转载于:https://www.cnblogs.com/chen-xing/p/10588184.html

    展开全文
  • 今天我给大家推荐10个高级程序员经常的网站,你又去过几个呢?来跟着小编一起看看都有哪些牛逼的网站吧。 分享之前我还是要推荐下我自己的前端学习群:653415492,不管你是小白还是大牛,小编我都挺欢迎,不定期...
  • MySQL是Java程序员面向高级的必备技能,很多朋友在面试时经常在这里折戟沉沙,饮恨不已。熟练掌握MySQL知识,在实践中具有很强操作性,尤其是在互联网行业,不仅要写好代码、实现功能,而且还要在高并发情况下...
  • 所以要定位到那些厉害的程序员和定期关注他们动态。</li></ul> 如果不想这么多,可以直接该项目首页</a>,Github Serendipity 会把下文提到好工具集成进来,帮助开发者快速发现值得...
  • 经常同佛罗里达附近SQL Server和.NET用户群体交流。Scott住在佛罗里达Wellington,当他不坐在计算机前时,你会发现他和自己家人在一起,或者骑着他雅马哈摩托车轰鸣在当地摩托车越野赛赛道上。你可以...
  • 经常同佛罗里达附近SQL Server和.NET用户群体交流。Scott住在佛罗里达Wellington,当他不坐在计算机前时,你会发现他和自己家人在一起,或者骑着他雅马哈摩托车轰鸣在当地摩托车越野赛赛道上。你可以...
  • 程序员老油条一起学前端!说起WebGl,想必有一半的前端小白们没有听说过这个东东,也很正常,随着前端技术的不断加速...经常做网站,会发现国外的网站特效就很炫,真的,一点也不吹,看看国内的企业官网,再看看...
  • 点击上方“Web前端进阶指南”关注我呦跟程序员小强一起学前端说起WebGl,想必有一半的前端小白们没有听说过这个东东,也很正常,随着前端...经常做网站,会发现国外的网站特效就很炫,真的,一点也不吹,看看国内的...
  • 以往他们只做一个宣传型的网站,做一个丢一个,每次一个新单只是换换美工,来年顶多就是收个几百元的域名空间费,这样的做法只够维持公司存活.现在考虑是不是可以再挖掘这些企业的其他需求.从网站建设入手,可以免费试用,...
  • 界面与逻辑分开,让程序员有更多时间去进行软件内部逻辑处理。SkinSE没有采用传统HOOK修改窗口过程函数方式 ,而是只是针对具体窗口进行界面处理。SkinSE只用到了windows几个底层核心库,没有用到(MFC/ATL...
  • 界面与逻辑分开,让程序员有更多时间去进行软件内部逻辑处理。SkinSE没有采用传统HOOK修改窗口过程函数方式 ,而是只是针对具体窗口进行界面处理。SkinSE只用到了windows几个底层核心库,没有用到(MFC/ATL...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    C#--微软.NET第一语言 本书着重介绍语言本身,比较少涉及应用,不错入门书,从头讲起,不怕不明白。 <<page 1>> page begin==================== 目 目目 目 录 录录 录 第一部分 C#语言概述.4 ...
  • C#微软培训资料

    2014-01-22 14:10:17
    以互相交换组件地方以互相交换组件地方 以互相交换组件地方 比尔 比尔比尔 比尔.盖茨 盖茨盖茨 盖茨 在本章中你将了解 Microsoft.NET 概念 .NET 框架 C#语言在.NET 框架中作用及其特性...
  • 本书也可作为高级程序员进军游戏业参考教材。我们在对RPG游戏剖析过程中,采取循序渐进方法,逐步揭示RPG游戏制作核心。不论在代码编写技巧上,还是制作结构上,都有适当高级内容提示。相信聪明读者通过...
  • 国外大佬写,国内翻译经典之作,虽然是经典但是不建议刚入门算法同学,因为了这本书你可能要放弃算法了,比较难懂。建议有了一定基础再入手这边书。 极客时间专栏 专栏质量都不错,但是基本都是收费...
  • c#学习笔记.txt

    2008-12-15 14:01:21
    完了前面几段,我朋友提出了不同意见:C#不是JavaClone,它只是长得有些像Java而已,其实面向对象、中间语言什么也不是什么新玩意儿,非Sun独创,有文为证:华山论剑:C#对Java。另外他对我上一集中说...
  • 直到2002年初的时候,几个朋友请我为他们的网站开发一款类似于kele8实影聊天室的聊天系统,于是我开发了新的聊天系统。虽然新的系统在设计思路与使用方式上完全不同于Copular Chat的前两个版本,但为了保持个人作品...
  • x-scan-v3.3-cn

    2013-09-23 21:36:56
    流光 国人骄傲,由高级程序员小榕编写一款强悍扫描器。大家都知道。就不介绍了。 X-way 一款优秀功能多线程扫描工具。也都应该用过。不作介绍了。 Nmap 这个就厉害了,安全界人人皆知非常有名气一个扫描...
  • 一是平时看的一些自己认为不错的文章总是很难整理,所以打算开一个项目管理这些,也可以分享给大家;二是记录自己平时所学的一些笔记,一些经历,以供将来翻阅;三是想系统地进阶学习一番,记录这个项目也是想激励...
  • 除本书外,还著有广受好评《Oracle专家高级编程》和《Oracle高效设计》。 作者: Thomas Kyte  Thomas Kyte是Oracle公司核心技术集团副总裁,从Oracle 7.0.9版本开始就一直任职于Oracle公司,不过,其实他从...
  • iPhone开发秘籍(第2版)--详细书签版

    热门讨论 2012-12-11 13:42:25
    涉及编程、数字媒体、网站设计和数码摄影等多个领域。Erica开发了十多个本地应用。他常在其iPhone编程博客发表些极有见地文章。 目录 封面 -26 封底 -25 扉页 -24 版权 -23 版权声明 -22 译者序 -20 致谢 -19 ...

空空如也

空空如也

1 2
收藏数 39
精华内容 15
关键字:

高级程序员经常看的网站