在 C/C++ 中，为了处理数组，您需要知道它的大小。因此，您必须始终“记住”此大小并将其作为参数拖入所有处理函数中。例如：
void foo(int* arr, size_t n) {
for (size_t i = 0; i < n; i++) {
arr[i] = i * i;
}
}
但是由于某种原因，释放资源时没有必要知道大小。free(arr)如果内存是通过malloc()or分配的，您可以简单地调用calloc()。或者，delete[] arr;如果内存是通过 operator 分配的，则可以使用 operator new int[n]。
问题是如果 C/C++ 不知道数组的大小，它如何知道要释放多少内存？函数free()和运算符delete[]不将数组的大小作为参数，而仅将指向数组的指针作为参数。如果 C / C ++ 可以以某种方式计算大小，那么为什么要不断地将它“拖”在一个单独的变量中呢？
通常需要使用Json，特别是它的读取和解析。在Java中，您通常知道您正在使用什么类型的变量，但是在解析 Json时，字段的类型可以是任何类型，这是令人困惑的。
解析Json的方法有哪些？怎么做？
在这里，我们说，如何从下面的Json中获取数据？
{
"firstName": "Json",
"lastName": "Smith",
"age": 30,
"address": {
"streetAddress": "666 1nd Street",
"city": "New York",
"state": "NY",
"postalCode": 10021
},
"phoneNumbers": [
{
"type": "home",
"number": "542 666-1234"
},
{
"type": "fax",
"number": "653 666-4567"
}
],
"friends": [
{
"firstName": "Test",
"lastName": "Snow",
"age": 20,
"phoneNumbers": [
{
"type": "home",
"number": "141 111-1234"
}
],
"friends": [
{
"firstName": "UnknownFirstName",
"lastName": "UnknownLastName",
"age": 999,
"phoneNumbers": [
{
"type": "home",
"number": "000 000-0000"
}
]
}
]
},
{
"firstName": "Flash",
"lastName": "Tompson",
"age": 23,
"phoneNumbers": [
{
"type": "home",
"number": "999 111-1234"
}
]
}
]
}
任务：编写一个尽可能短的代码，以大号符号字体显示输入的数字字符串。字体必须与问题中指定的完全一致。
示例：
接收到字符串“0123456789”作为输入，程序应输出到标准输出：
### # ##### ##### # ####### ##### ####### ##### #####
# # ## # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # #
# # # ##### ##### # # ###### ###### # ##### ######
# # # # # ####### # # # # # # #
# # # # # # # # # # # # # # # #
### ##### ####### ##### # ##### ##### # ##### #####
规则和限制：
int main() {}如果它是一个函数——在大小上不考虑这个函数声明的语法（对于 C），工作代码本身的大小很重要。\n或）标记到新行的过渡（显式或隐式\r\n）。比赛结束
第一名被@RusArt 占据，答案是 05AB1E，只有 91 个“字节”长。
第二名是@Anton Petrusevich的 perl answer，长 150 字节。
第三名是@retorta的 python答案，长 161 字节。
答案涵盖了多种压缩字体的方法。在准备比赛时，我考虑了其中的大部分。最容易实现且同时非常有效的是以 7 位水平编码压缩最多 70 个字节（我的原始编码在答案中给出在 postgresql 上。我们甚至设法通过更改 6-7 位并减去 2 来进入有效字符范围。的确，并非所有参与者都费心并花费宝贵的字节来编码从 0x20 到 0x7E 的可打印字符范围。编码是原样使用的，经常是8位甚至进入控制范围。原则上，此类编码有权在编写程序的平台上运行。虽然当程序无法在打印机上打印时我真的不喜欢它，但从一张纸上再次输入并且它会继续工作（你将无法在书中发布你的代码;））。
获胜者使用了完全不同的字体编码。包含 16 个可能的 7 字符字体元素（位编码）的字典和一个带有每个字符部件号的代码表，由于 05AB1E 语言的非标准代码页，它占用了 35 个“字节”（从技术上讲，这种语言使用了256个字素，被认为是“字节”，因为正好有256个字素，如果真的存在这样的码表，那么真的可以全部编码成一个字节）。不幸的是，其他语言的这种编码原则上是不可能的，因为在 256 个 ASCII 字节值中，31 个用于控制代码，而 128 个更高的值在平台之间传输不佳。
其他一些答案原则上使用了类似的字典方法，但他们没有使用二进制编码，因此字体占用了更多空间。在准备比赛的过程中，我什至考虑了用字典编码的几种选择。例如，经常出现的两个组合#####和应该用值为 10 和 11 的两个位进行编码，而其余选项为 5 和一个位值，其第一位为 0，以便# #区分前两位和其余 4 位的选项数。实际上，这在字体编码方面的增益非常小，同时，解码代码过于复杂且不适用于代码高尔夫，同样，很难将其放入常规的 ascii 代码中。
也可以在答案中找到完全不同的编码方式，例如在@Qwertiy的答案#中提供仅用连续数字编码重复和空格
不幸的是，没有参与者尝试使用垂直编码，即 其中元素是从中垂直取出的编码字符的 7 位。使用这种编码方法，可以获得很多重复。仔细看5689这几个数字，只有1和最后一竖不一样，其他都是一样的。当在这样的字符串中对重复进行编码时，可以实现与字典和位编码几乎相同的压缩。但在高尔夫练习中，由于解码代码量的增长，它的适用性又很差。
备选评级
不幸的是，不可能以真正反映我想从比赛中得到什么的方式制定规则。许多答案使用在其他字符编码中不起作用的字符或与 base64 含义接近的函数，即 将编码字符串表示为一个大数，因此代码不包含其自身的解码。在这个替代排名中，我反映了如果规则被精确制定的结果。
请在您的答案中注明字节数，以便更容易识别获胜者。
execute("ru.stackoverflow.com", "674415");.cssload-container,.cssload-cube{width:97px;height:97px;transform-style:preserve-3d}.cssload-container,.cssload-cube,.cssload-half1,.cssload-half2{transform-style:preserve-3d}.cssload-container{position:relative;margin:23px 84px;perspective:292px}.cssload-cube{animation:cube 11.5s forwards infinite;transform-origin:center 49px}.cssload-half1,.cssload-s1{top:0;transform-origin:50% 100%}.cssload-half1{height:39px;position:absolute;animation:half-fold 11.5s forwards infinite}.cssload-side{width:19px;height:19px;background:#ddd;position:absolute}.cssload-s1{left:39px;animation:s1ani 11.5s forwards infinite}.cssload-s2,.cssload-s3,.cssload-s4{left:39px;transform-origin:50% 0}.cssload-s2{top:19px;animation:s2ani 11.5s forwards infinite}.cssload-s3{top:39px;animation:s3ani 11.5s forwards infinite}.cssload-s4{top:58px;animation:s4ani 11.5s forwards infinite}.cssload-s5{left:19px;top:19px;transform-origin:100% 50%;animation:s5ani 11.5s forwards infinite}.cssload-s6{left:58px;top:39px;transform-origin:0 50%;animation:s6ani 11.5s forwards infinite}@keyframes cube{0%,30%{transform:rotateX(0)}40%{transform:rotateX(45deg) rotateY(0) rotate(45deg)}60%{transform:rotateX(60deg) rotateY(0) rotate(45deg)}65%,70%{transform:rotateX(60deg) rotate(45deg) rotate(180deg)}75%,80%{transform:rotateX(60deg) rotate(45deg) rotate(1turn)}90%{transform:rotateX(0) rotate(0) rotate(0)}}@keyframes s1ani{0%{opacity:1;transform:translateY(0);background:#ddd}40%{transform:rotateX(0);background:#ddd}50%{transform:rotateX(-90deg);background:#ddd}90%{transform:rotateX(-90deg)}}@keyframes s2ani{0%{opacity:0;transform:rotateX(-179deg)}10%{opacity:1;transform:rotateX(0)}40%{background:#ddd}45%,80%{background:#b4b4b4}65%{opacity:1;background:#b4b4b4}90%{opacity:1}to{opacity:0}}@keyframes s3ani{0%,10%{opacity:0;transform:rotateX(-179deg)}20%,90%{opacity:1;transform:rotateX(0)}40%{background:#ddd}45%{background:#969696}to{opacity:0}}@keyframes s4ani{0%,20%{opacity:0;transform:rotateX(-179deg)}10%,to{opacity:0}30%{opacity:1;transform:rotateX(0)}40%{transform:rotateX(0);background:#ddd}50%{transform:rotateX(90deg);background:#b4b4b4}80%{background:#b4b4b4}90%{opacity:1;transform:rotateX(90deg)}}@keyframes s5ani{0%,10%{opacity:0;transform:rotateY(-179deg)}20%{opacity:1;background:#ddd;transform:rotateY(0)}40%{transform:rotateY(0)}50%{transform:rotateY(90deg)}55%{background:#ddd}60%{background:#c8c8c8}90%{transform:rotateY(90deg);opacity:1}to{opacity:0}}@keyframes s6ani{0%,20%{opacity:0;transform:rotateY(179deg)}30%{opacity:1;transform:rotateY(0)}40%{transform:rotateY(0)}50%{transform:rotateY(-90deg);background:#ddd}60%,80%{background:#c8c8c8}90%{opacity:1;transform:rotateY(-90deg)}to{opacity:0}}@keyframes half-fold{0%,50%{transform:rotateX(0)}60%,90%{transform:rotateX(-90deg)}}<script src="https://mayorovp.github.io/codegolf/table-8c505e68f1349e4c69e7.js"></script>
<div class=cssload-container><div class=cssload-cube><div class=cssload-half1><div class="cssload-side cssload-s1"></div><div class="cssload-side cssload-s2"></div><div class="cssload-side cssload-s5"></div></div><div class=cssload-half2><div class="cssload-side cssload-s3"></div><div class="cssload-side cssload-s4"></div><div class="cssload-side cssload-s6"></div></div></div></div>世界早已习惯mysqli和PDO。许多人非常积极地推广它们：有准备好的变量，一切都变得安全，等等。
在这里，假设有一个抽象代码：
$dbh = new PDO("test");
$stmt = $dbh->prepare('SELECT * FROM users where username = :username');
$stmt->execute(array(':username' => $_REQUEST['username']));
或者
$dbh = new PDO("test");
$sth = $dbh->prepare('SELECT name, colour, calories FROM fruit WHERE calories < ? AND color = ?');
$sth->execute(array($_POST['number'], $_POST['color']));
和所有...
就这样就够了吗，不需要做更多的事情了吗？没有类型结构mysqli_real_escape_string（对于 mysqli）和其他萨满教？或者仍然不是？
实际上，我想知道如果上面的代码不保护，那么如何正确地处理带有PDOand的请求mysqli（以及为什么他们会谈论安全性）？有哪些关于如何使用PDOand安全地执行查询的明确示例mysqli？如果真相得到保护，那么……我很震惊））
PS 也许这个问题已经被考虑过了，我不知道，提前抱歉。
这是一个看起来很奇怪的 C++ 代码示例。出于某种原因，对数据进行排序后，代码的运行速度几乎快了六倍。
#include <algorithm>
#include <ctime>
#include <iostream>
int main()
{
// Заполнение данными
const unsigned arraySize = 32768;
int data[arraySize];
for (unsigned c = 0; c < arraySize; ++c)
data[c] = std::rand() % 256;
// !!! С этой строкой следующий цикл работает быстрее
std::sort(data, data + arraySize);
// Проверка
clock_t start = clock();
long long sum = 0;
for (unsigned i = 0; i < 100000; ++i)
{
// Основной цикл
for (unsigned c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;
std::cout << elapsedTime << std::endl;
std::cout << "sum = " << sum << std::endl;
}
std::sort(data, data + arraySize);，代码运行时间为 11.54 秒。起初，我以为语言或编译器有问题。所以我尝试使用 Java。
import java.util.Arrays;
import java.util.Random;
public class Main
{
public static void main(String[] args)
{
// Заполнение данными
int arraySize = 32768;
int data[] = new int[arraySize];
Random rnd = new Random(0);
for (int c = 0; c < arraySize; ++c)
data[c] = rnd.nextInt() % 256;
// !!! С этой строкой следующий цикл работает быстрее
Arrays.sort(data);
// Проверка
long start = System.nanoTime();
long sum = 0;
for (int i = 0; i < 100000; ++i)
{
// Основной цикл
for (int c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
System.out.println((System.nanoTime() - start) / 1000000000.0);
System.out.println("sum = " + sum);
}
}
结果，获得了类似的结果，但差距较小。
我的第一个想法是排序的时候，数据进入缓存，但后来我认为这是愚蠢的，因为刚刚创建了数组。