使用PHP合并PDF文件(Merge PDF files with PHP [closed])

 
 
 我看到很多人拥有一个巨大的源文件。 我是自学成才，所以不知道这是否有益或只是风格。 
 
 
 它通常更好的是具有较小的定义好的文件，而不是一个巨大的源文件。 每个文件都可以有一个C ++类定义或一组相关的函数。 一个粗略的指南不超过几百行C ++代码，但其主观性和难以量化。 你可能经常需要更少或更多。 
 
 
 
 人们说应该避免使用全局变量，那么我怎样才能在其他文件中提供的函数中声明变量。 
 
 
 您需要将这些变量作为参数传递给这些函数。 例如，如果run_game调用foo，并且foo需要知道当前分数，请将分数作为参数传递，如下所示： 
 
void run_game()
{
     int score = 0;

     ...
     foo(score);
}


void foo(int score)
{ 
    // do some stuff
}
 
 这被称为“按价值传递”，foo正在获得自己的分数副本。 因此，如果foo更新得分，则调用者的副本不会更新。 您可以让foo使用传递引用来更新分数，如下所示： 
 
void foo(int& score) // notice the ampersand
{
    // add 100 pts
    score += 100;
}
 
 现在你可能会问，我有50个变量，我怎么可能把所有50个变成foo？ 这就是软件工程的辛勤工作所在。 你有几个选择。 在任何选项中，你都要考虑如何将多个变量组合在一起。 你可能会发现你总是将相同的5个变量传递给函数foo。 也许这是对球员迄今在比赛中取得的成就的一些表示。 将这些聚集在一起的最简单方法是使用一个结构体： 
 
struct PlayerAccomplishments
{
    int playersScore;
    int numGoblinsSlayed;
    int numTrollsSlaved;
};
 
 现在你可以声明这种类型的变量，设置特定的字段并传递它们： 
 
void run_game()
{
     PlayerAccomplishments accomplishments;

     ...
     foo(accomplishments);
}


void foo(PlayerAccomplishments& playerAccomps)
{ 
    // do some stuff
    playerAccomps.numTrollsSlayed++;
    playerAccomps.playerScore += 100;
}
 
 抽象的下一步是将一组变量和常用功能包装到一个类中。 这使我们可以轻松地共享通用功能，并强制执行一个安全的，很好的方式来操作这些对象 - 由该对象的成员函数定义。 例如，如果我们有一个球员类。 
 
class Player
{
private:
    int score;
    int numTrollsSlayed;
public:
    // safely update the player's score after slaying a troll
    void SlayTroll(Troll& aTroll);
};

// in the cpp
Player::SlayTroll(Troll& aTroll)
{
    score += 100;
    numTrollsSlayed += 1;
}
 
 然后上面的代码变成： 
 
void run_game()
{
     Player aPlayer;

     ...
     foo(aPlayer);
}


void foo(Player& aPlayer)
{ 
    Troll someTroll;
    aPlayer.SlayTroll(someTroll); // updates aPlayer's score
}
 
 我希望你能看到有很多方法可以考虑这些问题，并且很难弄清楚如何分离事物。 这个答案几乎没有划伤表面。 我推荐一本好的课程或软件工程书籍 。 这东西很难。 具有数十年经验的真正聪明的人正在与组织和编写软件的最佳方式作斗争。 但是，想想这件事情是很棒的。 很高兴努力找到改进代码的方法，这样您就可以了解今天，明天和六个月后您要做什么。 

 
 
I see a lot of people having one giant source file. I am self taught so not sure if this has a benefit or is just style.
 
 
Its usually better to have smaller well defined files instead of one giant source file. Each file would either have a single C++ class definition or a set of interrelated functions. A rough guideline is no more than a few hundred lines of C++ code, but its subjective and difficult to quantify. You may often need much less or a lot more.
 
 
 
People say globals should be avoided so how can I make variables I declare in functions available in other files.
 
 
You need to pass those variables as parameters to those functions. For example if run_game calls foo, and foo needs to know the current score, pass the score in as an argument, like so:
 
void run_game()
{
     int score = 0;

     ...
     foo(score);
}


void foo(int score)
{ 
    // do some stuff
}
 
This is known as "pass by value", foo is getting its own copy of score. So if foo updates score, the caller's copy won't get updated. You can let foo update score by using pass by reference as so:
 
void foo(int& score) // notice the ampersand
{
    // add 100 pts
    score += 100;
}
 
Now you may ask, well I've got 50 variables, how could I possibly pass all 50 into foo? This is where the hard work of software engineering comes into play. You have a couple of options. In any option, you want to think about how pieces of variables group together. You might find you're always passing the same 5 variables into the function foo. Maybe its some representation of the players accomplishments so far in the game. The simplest way to gorup these together is with a struct:
 
struct PlayerAccomplishments
{
    int playersScore;
    int numGoblinsSlayed;
    int numTrollsSlaved;
};
 
Now you can declare variables of this type, set the specific fields, and pass them around:
 
void run_game()
{
     PlayerAccomplishments accomplishments;

     ...
     foo(accomplishments);
}


void foo(PlayerAccomplishments& playerAccomps)
{ 
    // do some stuff
    playerAccomps.numTrollsSlayed++;
    playerAccomps.playerScore += 100;
}
 
The next step in abstraction would be wrapping a set of variables and common pieces of functionality into a class. This lets us easily share common functionality and enforce a safe, well way for manipulating these objects--as defined by that object's member functions. So for example if we had a player class.
 
class Player
{
private:
    int score;
    int numTrollsSlayed;
public:
    // safely update the player's score after slaying a troll
    void SlayTroll(Troll& aTroll);
};

// in the cpp
Player::SlayTroll(Troll& aTroll)
{
    score += 100;
    numTrollsSlayed += 1;
}
 
Then the code above becomes:
 
void run_game()
{
     Player aPlayer;

     ...
     foo(aPlayer);
}


void foo(Player& aPlayer)
{ 
    Troll someTroll;
    aPlayer.SlayTroll(someTroll); // updates aPlayer's score
}
 
I hope you can see that there's a lot of ways to think about these problems, and its not easy to figure out how to seperate things out. This answer barely scratches the surface. I recommend a good course or book in software engineering. This stuff is hard. Really smart people with decades of experience struggle with the best way to organize and write software. But its great to think about this stuff. Its good to work hard to find ways to improve your code so you'll be able to make sense of what you're trying to do today, tomorrow, and six months from now.