成为C++高手之头文件与条件编译

书接上回（http://blog.csdn.net/niu_gao/article/details/51478789）。

但现在看起来真不爽，main.c依赖的文件不能在工程中管理，要修改那些文件的话麻烦大了。如何既能分成多个文件又能在工程中看到呢?可以，使用头文件（h文件）。

头文件中只放那些不产生内存占用的代码，比如定义结构（定义结构不会产生内存分配，只有用结构定义变量时才产生内存分配）、定义枚举，定义宏，声明变量，声明函数等。而且大都是一个c文件对应一个h文件。下面增加poker.h和player.h（注意main.c是不需要有h文件的，因为我们应该保证main.c只依赖别的文件，而不能被别的文件依赖），下面我们就把c文件中的结构、宏、枚举的定义移到对应的h文件中，然后再将变量和函数在h文件中增加声明，于是poker.h和player.h是这样的：

poker.h:

//一副牌的数量
#define CARD_COUNT 54
//定义扑克的花色
enum Suit{
    heart,
    spade,
    diamond,
    club,
    joker1,
    joker2
};
//定义扑克
typedef struct Card{
    int value;//牌的点数从1开始
    enum Suit suit;//花色
}Card;
//定义比较函数的类型
typedef int (*COMPARE)(Card* ,Card*);
extern Card pokers[CARD_COUNT];
void initOnePack();
char* getCardName(const Card*);
Card** shuffle(const Card*);
void sort(Card**,int,COMPARE);
int compare1(Card* ,Card*);
int compare2(Card* ,Card*);

player.h:

//定义玩家
typedef struct Player{
    char name[64];//玩家的名字
    Card ** cards;//玩家分到的牌。每项是一个指针，指向原始一副牌数组中的一项，这样可以节省空间
    int cardsCount;//玩家分到的牌的数量
}Player;
void dispatchCards(Player** ,int ,const Card** );

main.c中不再include poker.c和player.c，而是改为include 头文件。但是player.c和poker.c中也应该include各自的头文件，因为它们用到的结构、枚举等移到头文件中了（注意编译器不会自动将同名的h文件和c文件关联）。

其实还不够，player.h中用到了Card结构的定义，于是player.h依赖poker.h，所以应在player.h中include poker.h。然而不幸的是，现在又出现了一大堆错误，都是一些重定义或标志符冲突之类的错误。如何解决这些错误呢? 需使用条件编译指令！

我们看到过很多以#开头的令，比如#include、#define等。这些叫做编译指令。这些不产生实际的CPU指令，也就是说它们不是代码，但是编译器跟据它们处理代码的生成。这些编译指令还可以使用条件语句来控制编译器的动作，下面我们就为player.h增加条件编译指令来解决重定义错误。player.h变成了这样：

#ifndef PLAYER_H
#define PLAYER_H
#include "poker.h"
//定义玩家
typedef struct Player{
    char name[64];//玩家的名字
    Card ** cards;//玩家分到的牌。每项是一个指针，指向原始一副牌数组中的一项，这样可以节省空间
    int cardsCount;//玩家分到的牌的数量
}Player;
void dispatchCards(Player** ,int ,const Card** );
#endif //PLAYER_C

ifndef 表示if not defined，即如果没定义宏PLAYER_H，就使后面直到#endif之前的内容起作用。#define PLAYER_H表示定义宏PLAYER_H，即只有在宏PLAYER_H不存在时才定义它。定义之后它就存在了。试想如此一来，不论此文件被include多少次，只有第一次的内容起作用，于是就解决了重复定义问题。

现在各文件变成了这样：

poker.h:

#ifndef POKER_H
#define POKER_H
//一副牌的数量
#define CARD_COUNT 54
//定义扑克的花色
enum Suit{
    heart,
    spade,
    diamond,
    club,
    joker1,
    joker2
};
//定义扑克
typedef struct Card{
    int value;//牌的点数从1开始
    enum Suit suit;//花色
}Card;
//定义比较函数的类型
typedef int (*COMPARE)(Card* ,Card*);
extern Card pokers[CARD_COUNT];
void initOnePack();
char* getCardName(const Card*);
Card** shuffle(const Card*);
void sort(Card**,int,COMPARE);
int compare1(Card* ,Card*);
int compare2(Card* ,Card*);

#endif //POKER_H

poker.c:

#include <stdio.h>
#include "poker.h"
//原始一副牌所在的数组
Card pokers[CARD_COUNT];
//构造一副牌
void initOnePack(){
    int i=0;
    //前52张
    for(;i<CARD_COUNT-2;i++){
        pokers[i].value=i/4+1;
        pokers[i].suit = i%4;
    }
    //剩下的两张：大王和小王
    //joker1
    pokers[i].value=i/4+1;
    pokers[i].suit=joker1;
    //joker2
    pokers[i+1].value=i/4+2;
    pokers[i+1].suit=joker2;
}
//洗牌，参数是原始的一副牌，返回洗完后的牌
Card** shuffle(const Card* pokers){
    int i;
    //分牌返回牌数组的内存空间
    Card** retPokers = malloc(CARD_COUNT*sizeof(Card*));
    //为了不改动原始的一副牌，另建一个数组，保存原始牌的指针（注意每项不是牌，而是牌的指针）
    Card** pokers2 = malloc(CARD_COUNT*sizeof(Card*));
    for(i=0;i<CARD_COUNT;i++){
        pokers2[i] = &pokers[i];
    }
    //种下随机种子。种子取的是当前时间，
    //所以保证了每次运行程序时，产生的随机数序列不同
    srand(time(NULL));
    //取得随机序号，从pokers2取出序号所指的项，把它依次加到retPokers中。
    for(i=0;i<CARD_COUNT;i++){
        unsigned int index = rand()%CARD_COUNT;
        if(pokers2[index] != NULL){
            retPokers[i] = pokers2[index];
            pokers2[index]=NULL;
        }else{
            i--;
        }
    }
    free(pokers2);
    //返回洗完后的数组
    return retPokers;
}
//排序函数
//cards是要排序的牌，每一项是牌的指针
//cardsCount是牌的数量
//compare_func是比较函数
void sort(Card** cards,int cardsCount,COMPARE compare_func){
    int i;
    for(i=0;i<cardsCount-1;i++){
        int j;
        for(j=0;j<cardsCount-i-1;j++){
            if(compare_func(cards[j],cards[j+1])){
                int tmp=cards[j];
                cards[j]=cards[j+1];
                cards[j+1]=tmp;
            }
        }
    }
}
//比较函数，先比较点数再比较花色
int compare1(Card* a,Card* b){
    if(a->value > b->value){
        return 1;
    }else if(a->value < b->value){
        return 0;
    }else{
        if(a->suit > b->suit)
            return 1;
        else
            return 0;
    }
}
//比较函数，先比较点数再比较花色
int compare2(Card* a,Card* b){
    if(a->value > b->value){
        return 0;
    }else if(a->value < b->value){
        return 1;
    }else{
        if(a->suit > b->suit)
            return 0;
        else
            return 1;
    }
}
//获取牌的名字
//返回牌的名字字符串，调用者用完后需要free()之。
char* getCardName(const Card* card){
    //存放花色名字
    char suitStr[16]={0};//0==‘\0‘
    switch (card->suit) {
    case heart:
        strcpy(suitStr,"红桃");
        break;
    case spade:
        strcpy(suitStr,"黑桃");
        break;
    case diamond:
        strcpy(suitStr,"方块");
        break;
    case club:
        strcpy(suitStr,"梅花");
        break;
    }
    //存放点数名字
    char valueStr[16];
    switch(card->value){
    case 1:
        strcpy(valueStr,"A");
        break;
    case 11:
        strcpy(valueStr,"J");
        break;
    case 12:
        strcpy(valueStr,"Q");
        break;
    case 13:
        strcpy(valueStr,"K");
        break;
    case 14:
        strcpy(valueStr,"小王");
        break;
    case 15:
        strcpy(valueStr,"大王");
        break;
    default:
        sprintf(valueStr,"%d",card->value);
        break;
    }
    //动态分配足够的空间
    char * ret = malloc(16);
    //将两个名字合并到ret中
    sprintf(ret,"%s%s",suitStr,valueStr);
    return ret;
}
//#endif //POKER_C

player.h:

#ifndef PLAYER_H
#define PLAYER_H
#include "poker.h"
//定义玩家
typedef struct Player{
    char name[64];//玩家的名字
    Card ** cards;//玩家分到的牌。每项是一个指针，指向原始一副牌数组中的一项，这样可以节省空间
    int cardsCount;//玩家分到的牌的数量
}Player;
void dispatchCards(Player** ,int ,const Card** );
#endif //PLAYER_C

player.c:

//#ifndef PLAYER_C
//#define PLAYER_C
#include "player.h"
//发牌
//players是玩家数组
//playerCount是玩家数量
//shuffledCards是洗完后的一副牌
void dispatchCards(Player** players,int playerCount,const Card** shuffledCards){
    //计算每个玩家手中牌的数组的容量，如果每个玩家手中的牌不一样，
    //最多就差一张，加1是为了保证数组分配的空间足够容纳分到的牌。
    int numberCards = CARD_COUNT/playerCount+1;
    //为每个玩家的牌数组分配空间
    int i;
    for(i=0;i<playerCount;i++){
        Card* cards = malloc(numberCards*sizeof(Card*));
        players[i]->cards = cards;
    }
    //轮流向每个玩家发牌
    for(i=0;i<CARD_COUNT;i++){
        //取当前玩家
        Player *curPlayer = players[i%playerCount];
        //向玩家发牌
        curPlayer->cards[curPlayer->cardsCount] = shuffledCards[i];
        //玩家手中实际的牌数增加
        curPlayer->cardsCount++;
    }
}
//#endif //PLAYER_C

main.c:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "poker.h"
#include "player.h"
//函数声明们
//原始一副牌所在的数组
Card pokers[CARD_COUNT];
//入口函数
int main(void)
{
    //初始化一副牌
    initOnePack();

        //洗牌，shuffledPokers保存洗后的牌们
    Card** shuffledPokers = shuffle(pokers);
        //构建三个玩家
    Player player1;
    strcpy(player1.name,"隔壁老王");
    player1.cards=NULL;
    player1.cardsCount=0;
    Player player2;
    strcpy(player2.name,"小明");
    player2.cards=NULL;
    player2.cardsCount=0;
    Player player3;
    strcpy(player3.name,"田中龟孙");
    player3.cards=NULL;
    player3.cardsCount=0;
    //把三放到一个数组中，以传入发牌函数中
    Player* players[]={&player1,&player2,&player3};
        //发牌
    dispatchCards(players,sizeof(players)/sizeof(Player*),shuffledPokers);
        //洗后的牌用完了，释放之
    free(shuffledPokers);
    int i;
        //打印出每个玩家手中的牌
    for(i=0;i<sizeof(players)/sizeof(Player*);i++){
                //先打印玩家的名字
        printf("%s\n",players[i]->name);
                //需要对玩家手中的牌排序
        sort(players[i]->cards,players[i]->cardsCount,compare1);
                //打印玩家手中所有的牌
        int j;
        for(j=0;j<players[i]->cardsCount;j++){
            char * name = getCardName(players[i]->cards[j]);
            printf("%s ",name);
            free(name);
        }
        //每个玩家都需要换一次行
        printf("\n");
    }
        //释放玩家手中牌的数组
    for(i=0;i<sizeof(players)/sizeof(Player*);i++){
        free(players[i]->cards);
    }
    return 0;
}

可以看到，在main.c中，poker.h被include了，然后又被main.c又 include了player.h，而player.h中又include 了poker.h，所以在main.c中其实poker.h被include 了两次，但程序不会产生问题，为什么呢？就是用为使用了条件宏控制了编译过程。

上一篇：成为C++高手之提高可维护性

时间： 2024-12-20 18:32:00

成为C++高手之头文件与条件编译的相关文章

成为C++高手之头文件

但现在看起来真不爽,main.c依赖的文件不能在工程中管理,要修改那些文件的话麻烦大了.如何既能分成多个文件又能在工程中看到呢?可以,使用头文件(h文件). 头文件中只放那些不产生内存占用的代码,比如定义结构(定义结构不会产生内存分配,只有用结构定义变量时才产生内存分配).定义枚举,定义宏,声明变量,声明函数等.而且大都是一个c文件对应一个h文件.下面增加poker.h和player.h(注意main.c是不需要有h文件的,因为我们应该保证main.c只依赖别的文件,而不能被别的文件依赖),下面

预处理命令（宏定义，条件编译，头文件）

宏定义 <1>不带参数宏定义:#define PI 3.1415926 <2>带参数的宏定义: #define PI  3.1415926 #define S(r)  (PI*(r)*(r)) void main(){float  a=2,area;area=S(a); } 用宏可以得到几个结果: #define CIRCLE(R,L,S,V)  L=2*PI*(R);S=PI*(R)*(R);V=4.0/3.0*PI*(R)*(R)*(R) void main(){float r

C++ 包含头文件 和 宏的使用 和 条件编译

1 #define命令剖析 1.1   #define的概念     #define命令是C语言中的一个宏定义命令,它用来将一个标识符定义为一个字符串,该标识符被称为宏名,被定义的字符串称为替换文本.该命令有两种格式:一种是简单的宏定义,另一种是带参数的宏定义. (1)简单的宏定义: #define <宏名> <字符串> 例: #define PI 3.1415926 (2) 带参数的宏定义 #define <宏名> (<参数表>) <宏体> 例

C++中的头文件和源文件

一.C++编译模式通常,在一个C++程序中,只包含两类文件——.cpp文件和.h文件.其中,.cpp文件被称作C++源文件,里面放的都是C++的源代码:而.h文件则被称作C++头文件,里面放的也是C++的源代码.C+ +语言支持“分别编译”(separate compilation).也就是说,一个程序所有的内容,可以分成不同的部分分别放在不同的.cpp文件里..cpp文件里的东西都是相对独立的,在编 译(compile)时不需要与其他文件互通,只需要在编译成目标文件后再与其他的目标文件做一次链

C++中类的前置声明和包含头文件的区别

一.类嵌套的疑问 C++头文件重复包含实在是一个令人头痛的问题,假设我们有两个类A和B,分别定义在各自的头文件A.h和B.h中,但是在A中要用到B,B中也要用到A,但是这样的写法当然是错误的: class B; class A{ public: B b;}; class B{ public: A a;}; 因为在A对象中要开辟一块属于B的空间,而B中又有A的空间,是一个逻辑错误,无法实现的,在这里我们只需要把其中的一个A类中的B类型成员改成指针形式就可以避免这个无限延伸的怪圈了,为什么要更改A而

防止头文件多次引入

1.头文件被多次重复引用会造成的后果: 头文件多次重复引用:一个头文件被多次在源文件中多次引用. 先来看一段代码: /*Test.h*/ #include <stdio.h> int a = 10; /*Test.c*/ #include "Test.h" #include "Test.h" int main() {     printf("d o o\n");     return 0; } 显示结果: 出现了错误,由于多次引入同一

c++头文件

一.C++编译模式通常,在一个C++程序中,只包含两类文件——.cpp文件和.h文件.其中,.cpp文件被称作C++源文件,里面放的都是C++的源代码:而.h文件则被称作C++头文件,里面放的也是C++的源代码. C+ +语言支持“分别编译”(separate compilation).也就是说,一个程序所有的内容,可以分成不同的部分分别放在不同的.cpp文件里..cpp文件里的东西都是相对独立的,在编 译(compile)时不需要与其他文件互通,只需要在编译成目标文件后再与其他的目标文件做一次

C程序中头文件相互包含精华（转载）

C程序中头文件相互包含精华(网摘小结) 收藏(转自:http://blog.csdn.net/lingyun3429/archive/2010/04/27/5535191.aspx).h中一般放的是同名.c文件中定义的变量.数组.函数的声明,需要让.c外部使用的声明. 1)h文件作用 1 方便开发:包含一些文件需要的共同的常量,结构,类型定义,函数,变量申明: 2 提供接口:对一个软件包来说可以提供一个给外界的接口(例如: stdio.h). 2)h文件里应该有什么 常量,结构,类型定义,函数,

C预编译, 预处理, C/C++头文件, 编译控制，

在所有的预处理指令中,#Pragma 指令可能是最复杂的了,它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作.#pragma指令对每个编译器给出了一个方法,在保持与C和C++语言完全兼容的情况下,给出主机或操作系统专有的特征.依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的. 其格式一般为: #Pragma Para 其中Para 为参数,下面来看一些常用的参数. (1)message 参数. Message 参数是我最喜欢的一个参数,它能够在编译信息输出窗口中输