Atalanta U19 vs Chelsea U1carlosdelrio/CppPrimer/ch15/ex15.47.cpp
#include
#include
#include
#include
#include
using std::vector;
using std::string;
using std::list;
using std::cin;
using std::cout;
using std::endl;
void elimDups(vector &words)
{
sort(words.begin(), words.end());
auto end_unique = unique(words.begin(), words.end());
words.erase(end_unique, words.end());
}
void biggies(vector &words, vector::size_type sz)
{
elimDups(words);
stable_sort(words.begin(), words.end(),
[](const string &a, const string &b)
{ return a.size() = sz; });
auto count = words.end() – wc;
cout << count << " " << sz << "-character or longer word(s)" << endl;
for_each(wc, words.end(),
[](const string &s)
{ cout << s << " "; });
}
int main()
{
vector vec;
string temp;
while (cin >> temp)
vec.push_back(temp);
biggies(vec, 4);
}
carlosdelrio/CppPrimer<|file_sep/p11_12.cpp
// p11_12.cpp — demonstrate new and delete
#include
using std::cout;
using std::endl;
int main()
{
int *pi;
double *pd;
char *pc;
pi = new int; // allocate an int
*pi = 42;
cout << "The value of *pi is " << *pi << endl;
pd = new double; // allocate a double
*pd = 3.14;
cout << "The value of *pd is " << *pd << endl;
pc = new char; // allocate a char
*pc = 'c';
cout << "The value of *pc is " << *pc << endl;
delete pi; // deallocate the int
delete pd; // deallocate the double
delete pc; // deallocate the char
return 0;
}
carlosdelrio/CppPrimer<|file_sep/genericity.cpp
// genericity.cpp — demonstrate generic programming
#include
#include
#include
using std::cout;
using std::endl;
using std::vector;
using std::sort;
template
void print(const T &v)
{
for (auto i : v)
cout << i << " ";
}
int main()
{
vector v1{ 1, 2, 3, 4, 5 };
vector v2{ 1.1, 2.2, 3.3, 4.4 };
vector v3{ ‘a’, ‘b’, ‘c’ };
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
print(v1);
cout << endl;
print(v2);
cout << endl;
print(v3);
}carlosdelrio/CppPrimer<|file_sepcpp_primer_exercises/ch11/ex11.22.cpp
// ex11_22.cpp — Exercise 11.22: explain what happens when we make a pointer point to a block of memory allocated by new[], then use delete on that pointer.
#include
int main()
{
int* p = new int[10];
delete p;
// This is undefined behavior.
return 0;
}carlosdelrio/CppPrimer<|file_sep/cpp_primer_exercises/ch17/ex17.38.cpp
// ex17.38.cpp — Exercise 17.38: Redefine Sales_data's default constructor to set bookNo to an empty string and sales_revenue to 0.
#include
struct Sales_data {
Sales_data() : bookNo(“”), sales_revenue(0) {}
std::string bookNo;
double sales_revenue;
};<|file_sepcpp_primer_exercises/ch16/ex16.18.cpp
// ex16_18.cpp — Exercise 16.18: Write your own versions of StrVec that use a more efficient memory management strategy.
// Solution taken from https://github.com/Tessil/Cpp-Primer/blob/master/Chapter%2016/ex16_18/ex16_18.cpp
#include
#include
#include
class StrVec {
public:
StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) {}
StrVec(const StrVec& s) {
auto newdata = alloc_n_copy(s.begin(), s.end());
elements = newdata.first;
first_free = cap = newdata.second;
}
~StrVec() {
free();
}
StrVec& operator=(const StrVec&) = delete;
void push_back(const std::string&);
private:
static std::pair alloc_n_copy(const std::string*, const std::string*);
void free();
void reallocate();
private:
std::string* elements; // points to the start of the space allocated for elements
std::string* first_free; // one past the end of the used space
std::string* cap; // one past the end of the allocated space
};
std::pair StrVec::alloc_n_copy(const std::string* b, const std::string* e) {
auto data = alloc_array(e – b); // returns a pointer to memory that can hold e-b elements
auto dest = data; // points to the first element in data
for (; b != e; ++b, ++dest) {
new(dest) string(*b); // placement new copies each element from b into dest
}
return { data, dest };
}
void StrVec::free() {
for (auto p = elements; p != first_free; ++p) {
p->~basic_string(); // calls destructor for each element in range [elements, first_free)
}
free(elements); // frees elements from heap memory
}
void StrVec::reallocate() {
auto n = size();
auto old_size = n ? n : 1;
auto newdata = alloc_array(old_size * 2); // allocates space for twice as many elements
auto dest = newdata;
for (auto elem : elements) { // copies all the elements from old memory to newly allocated space
new(dest) string(std::move(*elem));
dest++;
}
free(); // frees old memory
cap = newdata + old_size * 2; // sets cap to point just past newly allocated memory space
first_free = dest; // sets first_free to point to the first unused element in newly allocated space
elements = newdata; // sets elements to point to beginning of newly allocated space
}
void StrVec::push_back(const std::string& s) {
if (first_free == cap) { // if there is no space left in current memory allocation…
reallocate(); // …allocate more space…
}
emplace_back(s); // add s to the back of our array using emplace_back()
}
int main() {
std::cout << "Hello World!" << std::endl;
return 0;
}<|file_sep delphi/
This folder contains Delphi source code examples.carlosdelrio/CppPrimer<|file_sep CPP Primer Exercices
==========================
Exercices for C++ Primer by Stanley B. Lippman and Josée Lajoie
### License
Copyright (c) 2019 Carlos Del Rio
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.carlosdelrio/CppPrimer<|file_sepcpp_primer_exercises/ch12/ex12.28.cpp
// ex12_28.cpp — Exercise 12.28: Write your own version of my_strcpy that uses memcpy instead.
#include
#include
#include
char* my_strcpy(char* dest, const char* src)
{
if (dest == nullptr || src == nullptr)
throw std::invalid_argument(“Null pointer passed as argument”);
size_t len_src{ strlen(src) };
char* ret_val{ dest };
while (*src != ”) {
*dest++ = *src++;
}
dest[0] = ”;
return ret_val;
}carlosdelrio/CppPrimer<|file_sep correção/correção_capítulo_5.md
# Capítulo 5: Operadores e expressões
## Notas
### Comentários
– Comentários devem ser usados para explicar porquê uma operação foi feita e não o que está sendo feito.
– O C++ permite comentários de linha única `//` e comentários de múltiplas linhas `/* */`.
### Construtores de classe
– O construtor de classe é uma função especial que é executada quando um objeto é criado.
– Ele não tem tipo de retorno nem nome especial.
– O nome da função deve ser o mesmo que o nome da classe.
– O construtor não pode ser chamado diretamente pelo usuário.
– Se não declararmos um construtor para uma classe então o compilador criará automaticamente um construtor padrão.
### Operadores unários
– Operadores unários são aqueles que só trabalham com um único operando.
– Sinais de incremento e decremento (`++` e `–`) são exemplos de operadores unários.
### Operadores binários
– Operadores binários são aqueles que trabalham com dois operandos.
– Eles são divididos em três grupos:
– Operadores aritméticos: `+`, `-`, `*`, `/`, `%`
– Operadores relacionais: `<`, `=`, `==`, `!=`
– Operadores lógicos: `!`, `&&`, `||`
### Precedência dos operadores
– Precedência determina qual operação deve ser realizada primeiro quando há mais de uma opção para escolher.
– A precedência é determinada pela posição do operador na tabela abaixo:
Precedência | Operador | Associatividade | Descrição do operador
—————————————————————–
20 | ! | Right | Negação lógica (unário)
19 | ++ | Right | Incremento pós-fixo
19 | — | Right | Decremento pós-fixo
18 | ++ | Left | Incremento pré-fixo
18 | — | Left | Decremento pré-fixo
17 | () | None | Chamada de função ou conversão de tipo explícita
17 | [] | None | Seleção de elemento em vetor ou matriz
16 | . | None | Seleção de membro
15 | ->* | None | Seleção de membro através de ponteiro
14 | -> | None | Seleção de membro através de ponteiro
13 | & | None | Referência
12 | + | None | Endereço
11 | – | None | Negativo
10 | ~ | None | Bitwise complementar
9 |- |- |- (subtração ou negação lógica)
8 |- |- |- (subtração ou negação lógica)
7 |- |- |- (subtração ou negação lógica)
6 |- |- |- (subtração ou negação lógica)
5 |- |- |- (subtração ou negação lógica)
4 |- |- |- (subtração ou negação lógica)
3 |- |- |- (subtração ou negação lógica)
2 *& |- *& (multiplicação ou desreferenciamento)
1 % %- % (módulo)
0 / / /
### Operações aritméticas com ponteiros
– Quando um número inteiro é somado a um ponteiro então o resultado será um ponteiro apontando para o elemento do vetor cujo índice é igual ao valor do inteiro adicionado ao índice do elemento apontado pelo ponteiro original.
– Quando um ponteiro é subtraído de outro então o resultado será um inteiro cujo valor é igual à diferença entre os índices dos elementos apontados pelos dois ponteiros.
### Conversões implícitas
– Em algumas situações o compilador realiza conversões automáticas entre tipos sem necessidade da intervenção do programador.
## Exercícios
### Exercício 5.21
#### Resposta
Se usarmos a seguinte declaração:
c++
double slope(double x0,double y0,double x1,double y1);
então podemos usar as seguintes chamadas:
c++
slope(1.,2.,3.,4.);
slope(x,y,x,y);
slope(x+5.,y,x+5.,y);
slope(a,b,c,d);
slope(x,y,z,w);
Porém não podemos usar as chamadas:
c++
slope(1.,x,y,z,w);
slope(1.,x,y,x,y+5.);
slope(1.,x+5.,y,x+5.,y);
Isso porque cada chamada deve ter exatamente quatro parâmetros.
### Exercício 5.22
#### Resposta
Não podemos realizar essa atribuição porque estamos tentando converter um inteiro em um ponteiro.
### Exercício 5.23
#### Resposta
Podemos usar os seguintes valores:
c++
v[0] + i;
v[i];
i + v[i];
v + i;
v[i] + j;
v[i] + k;
Porém não podemos usar os seguintes valores:
c++
i + v;
k + v[i];
j + v[i];
Isso porque os operandos devem ser passados na ordem correta para cada operador.
### Exercício 5.24
#### Resposta
A variável i recebe o valor apontado por p e a variável j recebe o valor apontado por q.
### Exercício 5.25
#### Resposta
O valor retornado será um ponteiro que aponta para o primeiro elemento do vetor.
### Exercício 5.26
#### Resposta
O código compila mas não faz nada útil.
### Exercício 5.27
#### Resposta
O código compila mas não faz nada útil.
### Exercício 5.28
#### Resposta
A variável i recebe o valor apontado por p e a variável j recebe o valor apontado por q+2.
### Exercício 5.29
#### Resposta
Podemos usar as seguintes chamadas:
c++
a();
a(b);
a(b,c);
a(b,c,d);
Porém não podemos usar as seguintes chamadas:
c++
a(d,b,c);
a(b,d,c);
a(c,b,d);
a(c,d,b);
a(d,c,b);
Isso porque os parâmetros passados como argumentos precisam estar na mesma ordem em que foram declarados na assinatura da função.
### Exercício 5.30
#### Resposta
O código compila mas não faz nada útil.
### Exercício 5.31
#### Resposta
A variável i recebe o valor apontado por p e a variável j recebe o valor apontado por q+2.
### Exercício 5.32
#### Resposta
As variáveis i e j recebem os valores dos elementos dos vetores indicados pelos ponteiros p e q respectivamente.
### Exercício 5.33
#### Resposta
A variável i recebe o valor apontado por p e a variável j recebe o valor apontado por q+2.
### Exercício 5.34
#### Resposta
O programa imprime as seguintes strings:
Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randy Newman Randym Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny Newmanny NewmanRandym NewmanRandym NewmanRandymNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanNewmanRandymNewmaRandymNewmaRandymNewmaRandymNewmaRandymNewmaRandymNewmaRandymRandy R RandymRandyRandyRandyRandyRandyRandyRandyRandyRandyRandyRandyRandyR
