C/C++

Declaration and Defination

遇君阁 — Thu, 03 Apr 2008 06:56:00 GMT

I summarize some case which is declaration in C++, and other is defination as bellow

Declaration:
int foo(int,int); //function declaration

typedef short INT16; //typedef declaration

extern int var; //external declaration

class bar; // class declaration, you also use struct,union,enum

friend test; // friend declaration

using std::cout; // namespace declaration

Defination:
int y;

class foo {...};

struct bar {...};

foo* p;

static int i;

enum Color{RED,GREEN,BLUE};

const double PI = 3.1415;

union Rep{...};

void test(int p) {};

foo a;

bar b;

Declaration and Defination in a Class:
// A.h header file
// class A is a defination.
class A
{
public:
         int a;     // a is a defination
         static int b;       // b is a declaration, you will difine it outside this class
         int getValue();        // method getValue is a declaration., you will difine it outside this class
         // method getValue1 is a defination, it is an inline function.
         int getValue1()
         {
                  return a;
         }
};

using声明与using 指示符

遇君阁 — Thu, 03 Apr 2008 06:38:00 GMT

Ø using 声明

using 声明是以关键字using 开头后面是名字空间成员名, 但是一次只能引入一个名字空间成员.。使用using声明的直接效果是允许程序员访问命名空间中的名字,而不需要加前缀namespace_name::。同时using 声明同其他声明的行为一样：它有一个域，它引入的名字从该声明开始直到其所在的域结束都是可见的。using 声明可以出现在全局域和任意名字空间中，同时它也可以出现在局部域中。

格式：using namespace::name;

Using声明的一个经常用法是使被子类覆盖的父类中的方法在子类中可见，如：

class Base {
private:
　int x;
public:
　virtual void mf1() = 0;
　virtual void mf1(int);
　virtual void mf2();
　void mf3();
　void mf3(double);
　...
};

class Derived: public Base {
public:
// make all things in Base named mf1 and mf3

// visible (and public) in Derived’s scope

　using Base::mf1; 　

using Base::mf3; 　

   virtual void mf1();
   void mf3();
   void mf4();
...
};

Ø using指示符

using指示符：是使用整个名字空间，其直接作用是使该名词空间下的所名字可见。

格式：using namespace namespace_name

　　using指示符语句可以加在程序文件的几乎任何地方，包括文件开头（#include语句之前）、函数内部。不过用using指定的名字空间作用域（生命周期）受using语句所在位置的生命周期约束。如，函数内部使用“using namespace myspacename;”则 myspacename仅在该函数内部可见。

可以用using语句指定多个名字空间，使得多个名字空间同时可见。但这增加了名字污染的可能性，而且只有在使用各名字空间相同成员时由多个using指示符引起的二义性错误才能被检测到，这将给程序的检测、扩展、移植带来很大的隐患。因此，应该尽量使用using声明而不是滥用using指示符。

附：

Ø Using声明与一般声明的区别

它们之间的区别在于，Using声明只引入了一个名称，而一般声明在引入一个名称的同时，还告诉我们这个

名称的signature是什么样子的。所以这里又有必要说明一下如何声明一个命名空间里的对象或者函数：

// a.cpp

namespace example

{

// class declaration in namespace

class A;

// function declaration in namespace

int foo();

}

External Linkage V.S Internal Linkage

遇君阁 — Thu, 06 Mar 2008 03:22:00 GMT

Compilation Units

A compilation unit is C/C++ source code that is compiled and treated as one logical unit. When C/C++ files is compiling, the preprocessor will include the header file recursively. Next the compilation unit will be compiled to object file(.o or .obj). Programs composed of more than one compilation unit can be separately compiled, and later linked to produce the executable program.

Internal Linkage

If a signature is local in its compilation unit, and it can't confilict with the same signature in other compilation units at link phase. We call this signature has internal linkage.

External Linkage

If a signature will be used to search by other compilation units. We call this signature has external linkage. In other words, if we define this signature in different compilation unit, the compiler will give us an error like: multiple name.

First, I must say all declaration in C++ is neither Internal linkage nor External Linkage, we called it No Linkage. Next I summarized some items to recognise whether a signature is external linkage or not:
1. In a class, the signature of member method defination, the signature of static member method defination and the signature of static member var defination has external linkage.
2. In a namespace(include global namespace), the signature of non-static function defination, the signature of non-static friend function defination and the signature of non-static variable defination  has external linkage.
We can use an example to prove it:
// A.h
class A
{
public:
        int foo();
}
// AA.cpp
#include “A.h“
int A::foo()
{
        return 0;
}
//AAA.cpp
#include “A.h“
int A::foo()
{
        return 1;
}
If you compile this code, you will get the“A::foo already defined in TestEnum.obj“ link error. Because the signature of member function defination has external linkage.If we modify the AAA.cpp file to:
// AAA.cpp
// no code, only include AAA.h
#include “A.h“
There is no error. We can see the signature of class defination has internal linkage.

I think other case is internal linkage except items that I summarized above, like the signature of class defination, the signature of union/enum defination etc. If you are a chariness person, you must find all signature with external linkage which can not be located in header file, only in cpp file. Reversely, all signature with internal linkage can be located in header file.

头文件不能不说的事

遇君阁 — Wed, 05 Mar 2008 05:46:00 GMT

头文件一般包含：
类型定义
模板声明
模板定义
函数声明
内联函数定义
数据声明
常量定义
枚举
包含指令
宏定义
注释
条件编译指令

““和<>搜索路径的区别--引自MSDN
""
This   form   instructs   the   preprocessor   to   look   for   include   files   in   the   same   directory   of   the   file   that   contains   the   #include   statement,   and   then   in   the   directories   of   any   files   that   include   (#include)   that   file.   The   preprocessor   then   searches   along   the   path   specified   by   the   /I   compiler   option,   then   along   paths   specified   by   the   INCLUDE   environment   variable.

<>
This   form   instructs   the   preprocessor   to   search   for   include   files   first   along   the   path   specified   by   the   /I   compiler   option,   then,   when   compiling   from   the   command   line,   along   the   path   specified   by   the   INCLUDE   environment   variable.

C&C++问题搜集

游游的家 — Thu, 18 Jan 2007 06:57:00 GMT

1、控制台输入结束的时候按下键盘上的Enter键，是往输入流中输入了几个字符？
是不是一个CR 一个LF，共2个字节？
那么为什么读的时候只能读到LF，读不到CR？
答：因为控制台io是以文本方式，而不是二进制方式打开的，所以其会将输入的\r\n转化为\n，会将输出的\n转化为\r\n

1、类中inline成员函数的定义为什么要放在头文件中？
答：因为调用者需要就地展开代码，如果找不到实现如何展开？所以内联函数一般放在头文件中。

选自周星星的blog
#include <stdio.h>

int main( void )
{
FILE* fp = fopen( "D:\\test.txt", "r+" ); // 文件内容：12345

    char c;
    fread( &c, 1, 1, fp ); // 函数返回1,c为'1' --- 也就是一切正确
    // fseek(fp,0,SEEK_CUR); --- [jzhang]和[argentmoon]说加上这一句就好了

fwrite( "a", 1, 1, fp ); // 函数返回1 --- 也就是一切正确

fclose( fp ); // 函数返回0 --- 也就是一切正确，然而文件内容仍然为 12345 而没有变为 1a345
return 0;
}

答：ouput cannot be directly followed by input without an intervening fflush, fseek, fsetpos, or rewind.

Input cannot be directly followed by output without an intervening fseek, fsetpos, or rewind, or an input operation that encounters an end of file.

常用代码搜集

遇君阁 — Wed, 13 Dec 2006 08:38:00 GMT

我在这里主要是搜集有用的代码，第一可以己用，第二也可以给同志们一个找代码的地方。

控制小数位数（摘自周星星的论坛答复和blog，自己稍微修改了一下）：
方法1：
#include <iostream>
#include <strstream>
#include <iomanip>
#include <cmath>
#include <string>
using namespace std;

void foo( double f, size_t n )
{
ostrstream ostr;
    double intpart;
    modf( f, &intpart );
    double lenf = log10( intpart );
    size_t len = (size_t)ceil( lenf );

ostr << setprecision(n+len) << f << '\0';
string numStr;
numStr = ostr.str();
cout << numStr <<endl;
cout << setprecision(n+len) << f << endl;
}

int main( void )
{

foo( 123.456, 2 );
}

方法2 ：

按有效位输出是 setprecision，按小数位数输出也是setprecision，但到底是谁取决于fixed。
cout << resetiosflags(ios::fixed) << setprecision(n) << float-point-number; 是按n位有效数输出
cout << setiosflags(ios::fixed) << setprecision(n) << float-point-number; 是按n位小数输出

测试代码：
#include <iostream>
#include <iomanip>
using namespace std;

int main( void )
{
const double value = 12.3456789;

    cout << value << endl; // 默认以6精度，所以输出为 12.3457
    cout << setprecision(4) << value << endl; // 改成4精度，所以输出为12.35
    cout << setprecision(8) << value << endl; // 改成8精度，所以输出为12.345679
    cout << fixed << setprecision(4) << value << endl; // 加了fixed意味着是固定点方式显示，所以这里的精度指的是小数位，输出为12.3457
    cout << value << endl; // fixed和setprecision的作用还在，依然显示12.3457
    cout.unsetf( ios::fixed ); // 去掉了fixed，所以精度恢复成整个数值的有效位数，显示为12.35
    cout << value << endl;
    cout.precision( 6 ); // 恢复成原来的样子，输出为12.3457
    cout << value << endl;
}

cin输入时,如何忽略回车换行符:
if(peek() == '\r'){ignore(1);}

如何赋值字符串的其中一段:
    string a="abcde";
    string b(a.begin()+1, a.begin()+3);

    string c;
    c = a.substr(1,2);

定义二维数组:
1. A (*ga)[n] = new A[m][n];
...
delete []ga;
缺点：n必须是已知
优点：调用直观，连续储存，程序简洁(经过测试，析构函数能正确调用)

2. A** ga = new A*[m];
    for(int i = 0; i < m; i++)
ga[i] = new A[n];
    ...
for(int i = 0; i < m; i++)
        delete []ga[i];
     delete []ga;
缺点：非连续储存，程序烦琐，ga为A**类型
优点：调用直观，n可以不是已知

3. A* ga = new A[m*n];
    ...
    delete []ga;
缺点：调用不够直观
优点：连续储存，n可以不是已知

4. vector<vector<A> > ga;
      ga.resize(m); //这三行可用可不用
    for(int i = 1; i < n; i++) //
       ga[i].resize(n); // ...
缺点：非连续储存，调试不够方便，编译速度下降，程序膨胀(实际速度差别不大)
优点：调用直观，自动析构与释放内存，可以调用stl相关函数，动态增长

5. vector<A> ga;
    ga.resize(m*n);
方法3,4的结合

6. 2的改进版(Penrose提供，在此感谢)
A** ga = new A*[m];
      ga[0] = new A[m*n];
    for(int i = 1; i < m; i++)
ga[i] = ga[i-1]+n;
      ...
        delete [] ga[0];
      delete [] ga;
缺点：程序烦琐，ga为A**类型优点：连续储存，调用直观，n可以不是已知附：1,2,3,6还有对应的malloc-free版本个人推荐1和4,2可以用4来代替，3,5调用太烦琐，毕竟源程序是拿来看的不是拿来运行的下面是一些错误和没成功的版本1. A* ga = new A[m][n]; 必然错误2. vector<A[n]> ga;  ga.resize(m);

C++ InstanceOf Version:
void foo( A& pSome)
{
// Here I have a pointer to an A
// but it could also be a B or a C object

if( dynamic_cast< B* >( pSome ) != 0 ) {
// it is a B object
B* = dynamic_cast< B* >( pSome );
// do something with it
}
else if( dynamic_cast< C* >( pSome ) != 0 ) {
// it is a C object
C* = dynamic_cast< C* >( pSome );
// do something with it
}
}

计算程序执行时间:
Method1:
#include "time.h"
int main( void )
{
clock_t start, finish;
double usetime;
start = clock();
// Here is your tested code
finish = clock();
usetime= (double)(finish - start) / CLOCKS_PER_SEC;
printf( "The second elapsed is: \n", usetime);
}
Method2:
// Return Clock Cycle Time
// It is only used for Pentium IV
inline   unsigned   __int64   GetCycleCount(void)
{
      _asm         _emit   0x0F
      _asm         _emit   0x31
}

字符串替换函数.
// 能替换所有的要替换的字符串,被替换的字符串和替换的字符串不一定一样长.
// pInput - 输入字符串.
// pOutput - 输出字符串, 要保证足够的空间可以存储替换后的字符串.
// pSrc - 要被替换的子字符串, 比如%user%
// pDst - 要替换成的字符串, 比如user1
// 注意:以上的字符串均要以'\0'结尾.
//
void Substitute(char *pInput, char *pOutput, char *pSrc, char *pDst)
{
char *pi, *po, *p;
int nSrcLen, nDstLen, nLen;

    // 指向输入字符串的游动指针.
    pi = pInput;
    // 指向输出字符串的游动指针.
    po = pOutput;
    // 计算被替换串和替换串的长度.
    nSrcLen = strlen(pSrc);
    nDstLen = strlen(pDst);

    // 查找pi指向字符串中第一次出现替换串的位置,并返回指针(找不到则返回null).
    p = strstr(pi, pSrc);
    if(p)
    {
        // 找到.
        while(p)
        {
            // 计算被替换串前边字符串的长度.
            nLen = (int)(p - pi);
            // 复制到输出字符串.
            memcpy(po, pi, nLen);
            memcpy(po + nLen, pDst, nDstLen);
            // 跳过被替换串.
            pi = p + nSrcLen;
            // 调整指向输出串的指针位置.
            po = po + nLen + nDstLen;
            // 继续查找.
            p = strstr(pi, pSrc);
        }
        // 复制剩余字符串.
        strcpy(po, pi);
    }
    else
    {
        // 没有找到则原样复制.
        strcpy(po, pi);
    }
}

关于中文的输入输出.
wcout.imbue(locale("chs"));
wchar_t test[] = L"测试Test";
wcout<<test<<endl;

// '我' =〉GB2312
    char   string1[] =   "THIS 我 A STRING";
    printf("%s\n",string1);
setlocale(LC_ALL, "chs");
wchar_t c = L'你';
printf("%C\n", c);
// '我' =〉Unicode
wchar_t string2[] =   L"THIS 我 A STRING";
wprintf(L"%s\n",string2);

如何使用GCC和VS生成编译不同阶段的产物

游游的家 — Wed, 13 Dec 2006 08:27:00 GMT

个人以为一个程序员最起码要对编译器的编译过程要有一个基本的了解，这样做的好处便可以从不同编译阶段的角度来考虑程序的正确性、效率和程序出错时的错误分析，所以我想把这个话题再说一说，希望对大家有用。程序的编译过程基本上需要经历预处理、编译、汇编、连接这四个阶段，如下图所示：

然后我想用GCC，VS针对这几个不同阶段生成的产物来简单说明一下这几个过程。并且在一般我们使用的IDE里，如VC,DEV C++，一般把前三个阶段作为一个阶段来处理。所以我们了解一下如何产生编译中间产物的过程也是必要的。

在预处理阶段，输入的是C语言的源文件，通常为*.c。它们通常带有.h之类头文件的包含文件。这个阶段主要处理源文件中的#ifdef、 #include和#define命令。该阶段GCC和VS都会生成一个中间文件*.i，但实际工作中通常不用专门生成这种文件，因为基本上用不到；若非要生成这种文件不可，可以利用下面的示例GCC命令和VS要加的编译选项如下所示：

GCC

GCC -E test.c -o test.i

PROJECT|SETTINGS|C/C++|Project|Options中，加上/P

在编译阶段，输入的是中间文件*.i，编译后生成汇编语言文件*.s，VS是生成*.asm文件。这个阶段对应的GCC命令和VS要加的编译选项如下所示：

GCC

GCC -S test.i -o test.s

PROJECT|SETTINGS|C/C++|Project|Options中，加上/FA

在汇编阶段，将输入的汇编文件*.s或*.asm转换成机器语言*.o或者*.obj。这个阶段对应的GCC命令如下所示：

GCC

GCC -c test.s -o test.o

最后，在连接阶段将输入的机器代码文件*.s（与其它的机器代码文件和库文件）汇集成一个可执行的二进制代码文件。这一步骤，可以利用下面的示例命令完成：

GCC test.o -o test